xref: /utopia/UTPA2-700.0.x/modules/hdmi/drv/mhl/drvMHL.c (revision 53ee8cc121a030b8d368113ac3e966b4705770ef) 
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 /// file    mdrv_mhl.c
81 /// @author MStar Semiconductor Inc.
82 /// @brief  MHL driver Function
83 ///////////////////////////////////////////////////////////////////////////////////////////////////
84 
85 #ifndef _DRV_MHL_C_
86 #define _DRV_MHL_C_
87 
88 //-------------------------------------------------------------------------------------------------
89 //  Include Files
90 //-------------------------------------------------------------------------------------------------
91 // Common Definition
92 #include "MsCommon.h"
93 #include "MsVersion.h"
94 #include "MsIRQ.h"
95 #include "MsOS.h"
96 #ifdef MSOS_TYPE_LINUX_KERNEL
97 #include <linux/string.h>
98 #else
99 #include <string.h>
100 #endif
101 
102 #include "utopia.h"
103 #include "utopia_dapi.h"
104 
105 #include "mdrv_mhl_st.h"
106 #include "apiMHL_private.h"
107 #include "apiMHL.h"
108 #include "halMHL.h"
109 #include "drvMHL.h"
110 
111 #include "drvSYS.h"
112 #include "drvMMIO.h"
113 
114 //-------------------------------------------------------------------------------------------------
115 //  Local Defines
116 //-------------------------------------------------------------------------------------------------
117 #if(defined(CONFIG_MLOG))
118 #include "ULog.h"
119 
120 #define MDRV_MHL_MSG_INFO(format, args...)      ULOGI("MHL", format, ##args)
121 #define MDRV_MHL_MSG_WARNING(format, args...)   ULOGW("MHL", format, ##args)
122 #define MDRV_MHL_MSG_DEBUG(format, args...)     ULOGD("MHL", format, ##args)
123 #define MDRV_MHL_MSG_ERROR(format, args...)     ULOGE("MHL", format, ##args)
124 #define MDRV_MHL_MSG_FATAL(format, args...)     ULOGF("MHL", format, ##args)
125 
126 #else
127 #define MDRV_MHL_MSG_INFO(format, args...)      printf(format, ##args)
128 #define MDRV_MHL_MSG_WARNING(format, args...)   printf(format, ##args)
129 #define MDRV_MHL_MSG_DEBUG(format, args...)     printf(format, ##args)
130 #define MDRV_MHL_MSG_ERROR(format, args...)     printf(format, ##args)
131 #define MDRV_MHL_MSG_FATAL(format, args...)     printf(format, ##args)
132 
133 #endif
134 
135 #define MHL_DEBUG_RECEIVE_MSC       0
136 #define MHL_DEBUG_TIMER_EVENT       0
137 #define MHL_DEBUG_SOURCE_INFO       0
138 #define MHL_DEBUG_BIST_MODE         0
139 #define MHL3_AUTO_EQ_ENABLE         1
140 
141 //-------------------------------------------------------------------------------------------------
142 //  Local Structures
143 //-------------------------------------------------------------------------------------------------
144 
145 //-------------------------------------------------------------------------------------------------
146 //  Global Variables
147 //-------------------------------------------------------------------------------------------------
148 
149 //-------------------------------------------------------------------------------------------------
150 //  Local Variables
151 //-------------------------------------------------------------------------------------------------
152 #if(MHL_USE_UTOPIA_VERSION == MHL_UTOPIA_VERSION_10)
153 MHL_RESOURCE_PRIVATE stMHLResourcePrivate;
154 
155 #endif
156 
157 //-------------------------------------------------------------------------------------------------
158 //  Local Functions
159 //-------------------------------------------------------------------------------------------------
160 
161 //**************************************************************************
162 //  [Function Name]:
163 //                   _mdrv_mhl_InitRiuBase()
164 //  [Description]
165 //
166 //  [Arguments]:
167 //
168 //  [Return]:
169 //
170 //**************************************************************************
_mdrv_mhl_InitRiuBase(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate)171 MS_BOOL _mdrv_mhl_InitRiuBase(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate)
172 {
173     MS_BOOL bGetBaseFlag = FALSE;
174     MS_VIRT ulRiuBaseAddress = 0;
175     MS_VIRT ulPMRiuBaseAddress = 0;
176     MS_PHY ulNonPMBankSize = 0;
177     MS_PHY ulPMBankSize = 0;
178 
179     // get MMIO base
180     if(!MDrv_MMIO_GetBASE(&ulRiuBaseAddress, &ulNonPMBankSize, MS_MODULE_XC))
181     {
182         MDRV_MHL_MSG_ERROR("** MHL get XC base failed\n");
183     }
184     else if(!MDrv_MMIO_GetBASE(&ulPMRiuBaseAddress, &ulPMBankSize, MS_MODULE_PM))
185     {
186         MDRV_MHL_MSG_ERROR("** MHL get PM base failed\n");
187     }
188     else
189     {
190         pMHLResourcePrivate->ulRiuBaseAddress = ulRiuBaseAddress;
191         pMHLResourcePrivate->ulPMRiuBaseAddress = ulPMRiuBaseAddress;
192 
193         mhal_mhl_SetRegisterBaseAddress(pMHLResourcePrivate->ulRiuBaseAddress, pMHLResourcePrivate->ulPMRiuBaseAddress);
194 
195         bGetBaseFlag = TRUE;
196     }
197 
198     return bGetBaseFlag;
199 }
200 
201 //**************************************************************************
202 //  [Function Name]:
203 //                  _mdrv_mhl_ClearCbusFlag
204 //  [Description]
205 //
206 //  [Arguments]:
207 //
208 //  [Return]:
209 //
210 //**************************************************************************
_mdrv_mhl_ClearCbusFlag(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate,MS_U8 ucSelect)211 void _mdrv_mhl_ClearCbusFlag(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate, MS_U8 ucSelect)
212 {
213     MS_U8 uctemp = 0;
214 
215     switch(ucSelect)
216     {
217         case MHL_CLEAR_INITIAL_FLAG:
218             pMHLResourcePrivate->ulSystemIndex = 0;
219             pMHLResourcePrivate->ulCurrentTimerTick = (MsOS_GetSystemTime()) %CBUS_TIMER_CONTROL_MASK;
220             pMHLResourcePrivate->uc3DTotalEntryDTD = 0;
221             pMHLResourcePrivate->uc3DTotalEntryVIC = 0;
222             pMHLResourcePrivate->ucBISTModeState = MHL_CBUS_BIST_NONE;
223             pMHLResourcePrivate->ucCallBackFunctionIndex = 0;
224             pMHLResourcePrivate->slMHLPollingTaskID = -1;
225             pMHLResourcePrivate->usPrePowerState = 0;
226             pMHLResourcePrivate->ucHighEndVICTotalEntry = 0;
227             pMHLResourcePrivate->stSignalStatusInfo.ucImpedanceValue = MHL_IMPEDANCE_VALUE;
228             pMHLResourcePrivate->stSignalStatusInfo.ucImpedanceOffset = MHL_IMPEDANCE_VALUE;
229             pMHLResourcePrivate->stSignalStatusInfo.ucIControlValue = 0;
230 
231             for(uctemp = 0; uctemp <MHL_3D_VIC_INFORMATION_LENGTH; uctemp++)
232             {
233                 if(uctemp < MHL_3D_DTD_INFORMATION_LENGTH)
234                 {
235                     pMHLResourcePrivate->uc3DInformationDTD[uctemp] = 0;
236                 }
237 
238                 if(uctemp < MHL_3D_VIC_INFORMATION_LENGTH)
239                 {
240                     pMHLResourcePrivate->uc3DInformationVIC[uctemp] = 0;
241                 }
242 
243                 if(uctemp < MHL_HEV_VIC_INFORMATION_LENGTH)
244                 {
245                     pMHLResourcePrivate->usHighEndVICTable[uctemp] = 0;
246                 }
247 
248                 if(uctemp < MHL_AUDIO_TUNNEL_INFORMATION_LENGTH)
249                 {
250                     pMHLResourcePrivate->ulAudioTunnelTable[uctemp] = 0;
251                 }
252 
253                 if(uctemp < MHL_EMSC_SUPPORT_INFORMATION_LENGTH)
254                 {
255                     pMHLResourcePrivate->usEMSCSupportTable[uctemp] = 0;
256                 }
257             }
258 
259             //pMHLResourcePrivate->usHighEndVICTable[0] = MHL_HEV_VIC_INDEX0;
260             //pMHLResourcePrivate->usHighEndVICTable[1] = MHL_HEV_VIC_INDEX1;
261             //pMHLResourcePrivate->usHighEndVICTable[2] = MHL_HEV_VIC_INDEX2;
262             //pMHLResourcePrivate->usHighEndVICTable[3] = MHL_HEV_VIC_INDEX3;
263             //pMHLResourcePrivate->usHighEndVICTable[4] = MHL_HEV_VIC_INDEX4;
264             //pMHLResourcePrivate->usHighEndVICTable[5] = MHL_HEV_VIC_INDEX5;
265 
266             pMHLResourcePrivate->ulAudioTunnelTable[0] = MHL_AUDIO_TUNNEL_INDEX0;
267             pMHLResourcePrivate->ulAudioTunnelTable[1] = MHL_AUDIO_TUNNEL_INDEX1;
268             pMHLResourcePrivate->ulAudioTunnelTable[2] = MHL_AUDIO_TUNNEL_INDEX2;
269             pMHLResourcePrivate->ulAudioTunnelTable[3] = MHL_AUDIO_TUNNEL_INDEX3;
270             pMHLResourcePrivate->ulAudioTunnelTable[4] = MHL_AUDIO_TUNNEL_INDEX4;
271             pMHLResourcePrivate->ulAudioTunnelTable[5] = MHL_AUDIO_TUNNEL_INDEX5;
272 
273             pMHLResourcePrivate->usEMSCSupportTable[0] = MHL_EMSC_SUPPORT_BURST_ID0;
274             pMHLResourcePrivate->usEMSCSupportTable[1] = MHL_EMSC_SUPPORT_BURST_ID1;
275             pMHLResourcePrivate->usEMSCSupportTable[2] = MHL_EMSC_SUPPORT_BURST_ID2;
276             pMHLResourcePrivate->usEMSCSupportTable[3] = MHL_EMSC_SUPPORT_BURST_ID3;
277             pMHLResourcePrivate->usEMSCSupportTable[4] = MHL_EMSC_SUPPORT_BURST_ID4;
278             pMHLResourcePrivate->usEMSCSupportTable[5] = MHL_EMSC_SUPPORT_BURST_ID5;
279 
280             break;
281 
282         case MHL_CLEAR_CABLE_LOSS_FLAG:
283         case MHL_CLEAR_CONNECT_LOSS_FLAG:
284             pMHLResourcePrivate->ucProcDoneIndex = 0;
285             pMHLResourcePrivate->usDisplayIndex = 0;
286             pMHLResourcePrivate->ulCbusReceiveIndex = 0;
287             pMHLResourcePrivate->ulCbusSendIndex = 0;
288             pMHLResourcePrivate->ucPreRCPKeyCode = 0;
289             pMHLResourcePrivate->ulEnableIndex = 0;
290             pMHLResourcePrivate->ucWriteBurstState = MHL_CBUS_WRITE_BURST_NONE;
291             pMHLResourcePrivate->ucFeatureRequestState = MHL_CBUS_FEATURE_NONE;
292             pMHLResourcePrivate->ucECbusState = MHL_ECBUS_STATE_NONE;
293             pMHLResourcePrivate->ucECbusTrainState = MHL_ECBUS_STATE_DISABLE;
294             pMHLResourcePrivate->ucWriteBurstSequence = 0;
295             pMHLResourcePrivate->usEMSCTxBufferSize = MHL_EMSC_DATA_SIZE;
296             pMHLResourcePrivate->usEMSCRxBufferSize = MHL_EMSC_DATA_SIZE;
297             pMHLResourcePrivate->ucEMSCSendStatus = MHL_EMSC_SEND_NONE;
298 
299             for(uctemp = 0; uctemp <MHL_CBUS_TOTAL_QUEUE_NUM; uctemp++)
300             {
301                 pMHLResourcePrivate->stCbusQueueInfo[uctemp].ucQueueState = MHL_QUEUE_STATE_IDLE;
302             }
303 
304             pMHLResourcePrivate->stSignalStatusInfo.bECbusEnableFlag = FALSE;
305             pMHLResourcePrivate->stSignalStatusInfo.bBISTEnableFlag = FALSE;
306             pMHLResourcePrivate->stSignalStatusInfo.bClockStableFlag = FALSE;
307             pMHLResourcePrivate->stSignalStatusInfo.bAutoEnableFlag = FALSE;
308             pMHLResourcePrivate->stSignalStatusInfo.bSignalStableFlag = FALSE;
309             pMHLResourcePrivate->stSignalStatusInfo.ucAutoEQState = MHL_AUTO_EQ_START;
310             pMHLResourcePrivate->stSignalStatusInfo.ucStableCount = 0;
311             pMHLResourcePrivate->stSignalStatusInfo.ucECbusTrainState = MHL_EMSC_SEND_NONE;
312 
313             break;
314 
315         case MHL_CLEAR_CBUS_TIME_OUT_FLAG:
316             break;
317 
318         case MHL_CLEAR_MSG_RESPONSE_FLAG:
319             break;
320 
321         default:
322 
323             break;
324     };
325 }
326 
327 //**************************************************************************
328 //  [Function Name]:
329 //                  _mdrv_mhl_CbusGetLeastFlag()
330 //  [Description]:
331 //                  MHL Cbus get the least True flag in index
332 //  [Arguments]:
333 //
334 //  [Return]:
335 //
336 //**************************************************************************
_mdrv_mhl_CbusGetLeastFlag(MS_U8 unindex)337 MS_U8 _mdrv_mhl_CbusGetLeastFlag(MS_U8 unindex)
338 {
339     MS_U8 uctemp = BIT(0);
340 
341     if(unindex == 0)
342     {
343         return unindex;
344     }
345 
346     while(!(unindex &uctemp))
347     {
348         uctemp = uctemp <<1;
349     }
350 
351     return uctemp;
352 }
353 
354 //**************************************************************************
355 //  [Function Name]:
356 //                  _mdrv_mhl_GetLeastBitNum()
357 //  [Description]:
358 //
359 //  [Arguments]:
360 //
361 //  [Return]:
362 //
363 //**************************************************************************
_mdrv_mhl_GetLeastBitNum(MS_U16 usData)364 MS_U8 _mdrv_mhl_GetLeastBitNum(MS_U16 usData)
365 {
366     MS_U8 uctemp = 0;
367 
368     while(!(usData &BIT(0)))
369     {
370         usData = usData >>1;
371         uctemp++;
372     }
373 
374     return uctemp;
375 }
376 
377 //**************************************************************************
378 //  [Function Name]:
379 //                  mdrv_mhl_CbusSetPacket(BYTE ucHeader, Bool bControl, BYTE ucContent)
380 //  [Description]
381 //                  MHL Cbus Packet setting
382 //  [Arguments]:
383 //                  ucHeader: Packet header type
384 //                  bControl: Packet control bit type
385 //                  ucContent: Packet payload
386 //  [Return]:
387 //                  Packet word for register write
388 //**************************************************************************
_mdrv_mhl_CbusSetPacket(MS_U8 ucHeader,MS_BOOL bControl,MS_U8 ucContent)389 MS_U16 _mdrv_mhl_CbusSetPacket(MS_U8 ucHeader, MS_BOOL bControl, MS_U8 ucContent)
390 {
391     MS_BOOL bParity = 0;
392     MS_U16 usPacket = (ucHeader <<9) |(bControl <<8) |ucContent;
393 
394     do
395     {
396         bParity ^= (usPacket & BIT(0));
397         usPacket = usPacket >>1;
398     }
399     while(usPacket);
400 
401     usPacket = (bParity <<11) |(ucHeader <<9) |(bControl <<8) |ucContent;
402 
403     return (usPacket |BIT(15));
404 }
405 //**************************************************************************
406 //  [Function Name]:
407 //                  _mdrv_mhl_CbusTxWriteCommand()
408 //  [Description]:
409 //                  MHL Cbus send command
410 //  [Arguments]:
411 //
412 //  [Return]:
413 //                  TRUE: Cbus command send successfully
414 //                  FALSE: Cbus command send fail
415 //**************************************************************************
_mdrv_mhl_CbusTxWriteCommand(MS_BOOL bECbusEnableFlag,stMHL_QUEUE_INFO * stCbusQueueInfo)416 MS_BOOL _mdrv_mhl_CbusTxWriteCommand(MS_BOOL bECbusEnableFlag, stMHL_QUEUE_INFO *stCbusQueueInfo)
417 {
418     MS_BOOL bIndex = TRUE;
419     MS_U8 uctemp = 0;
420     mhalCbusFifo_S pCbusFifo;
421 
422     pCbusFifo.databuf[0] = _mdrv_mhl_CbusSetPacket(MSC_HEADER, CBUS_CONTROL, stCbusQueueInfo->ucCommand);
423 
424     switch(stCbusQueueInfo->ucCommand)
425     {
426         case MSC_ACK:
427             pCbusFifo.lens = stCbusQueueInfo->ucLength;
428             //pCbusFifo.databuf[0] = _mdrv_mhl_CbusSetPacket(MSC_HEADER, CBUS_CONTROL, MSC_ACK);
429 
430             if(stCbusQueueInfo->ucLength == 2)
431             {
432                 // payload 2
433                 pCbusFifo.databuf[1] = _mdrv_mhl_CbusSetPacket(MSC_HEADER, CBUS_DATA, stCbusQueueInfo->ucData[0]);
434             }
435             break;
436 
437         case MSC_NACK:
438             pCbusFifo.lens = 1;
439             //pCbusFifo.databuf[0] = _mdrv_mhl_CbusSetPacket(MSC_HEADER, CBUS_CONTROL, MSC_NACK);
440             break;
441 
442         case MSC_ABORT:
443             pCbusFifo.lens = 1;
444             //pCbusFifo.databuf[0] = _mdrv_mhl_CbusSetPacket(MSC_HEADER, CBUS_CONTROL, MSC_ABORT);
445             break;
446 
447         case MSC_WRITE_STAT_OR_SET_INT: // 0x60
448         case MSC_WRITE_XSTAT: // 0x70
449             // payload 1
450             //pCbusFifo.databuf[0] = _mdrv_mhl_CbusSetPacket(MSC_HEADER, CBUS_CONTROL, MSC_WRITE_STAT_OR_SET_INT);
451             // payload 2
452             pCbusFifo.databuf[1] = _mdrv_mhl_CbusSetPacket(MSC_HEADER, CBUS_DATA, stCbusQueueInfo->ucData[0]);
453             // payload 3
454             pCbusFifo.databuf[2] = _mdrv_mhl_CbusSetPacket(MSC_HEADER, CBUS_DATA, stCbusQueueInfo->ucData[1]);
455             // message length
456             pCbusFifo.lens = 3;
457             break;
458 
459         case MSC_READ_DEVCAP: // 0x61
460         case MSC_READ_XDEVCAP: // 0x71
461             // payload 1
462             //pCbusFifo.databuf[0] = _mdrv_mhl_CbusSetPacket(MSC_HEADER, CBUS_CONTROL, MSC_READ_DEVCAP);
463             // payload 2
464             pCbusFifo.databuf[1] = _mdrv_mhl_CbusSetPacket(MSC_HEADER, CBUS_DATA, stCbusQueueInfo->ucData[0]);
465             // message length
466             pCbusFifo.lens = 2;
467             break;
468 
469         case MSC_GET_STATE: // 0x62
470         case MSC_GET_VENDOR_ID: // 0x63
471         case MSC_SET_HPD: // 0x64
472         case MSC_CLR_HPD: // 0x65
473         case MSC_GET_SC1_ERRORCODE: // 0x69 - Get channel 1 command error code
474         case MSC_GET_DDC_ERRORCODE: // 0x6A - Get DDC channel command error code.
475         case MSC_GET_MSC_ERRORCODE: // 0x6B - Get MSC command error code.
476         case MSC_GET_SC3_ERRORCODE: // 0x6D - Get channel 3 command error code.
477             // payload 1
478             //pCbusFifo.databuf[0] = _mdrv_mhl_CbusSetPacket(MSC_HEADER, CBUS_CONTROL, pReq->cmd);
479             // message length
480             pCbusFifo.lens = 1;
481             break;
482 
483         case MSC_MSC_MSG: // 0x68
484             // payload 1
485             //pCbusFifo.databuf[0] = _mdrv_mhl_CbusSetPacket(MSC_HEADER, CBUS_CONTROL, MSC_MSC_MSG);
486             // payload 2
487             pCbusFifo.databuf[1] = _mdrv_mhl_CbusSetPacket(MSC_HEADER, CBUS_DATA, stCbusQueueInfo->ucData[0]);
488             // payload 3
489             pCbusFifo.databuf[2] = _mdrv_mhl_CbusSetPacket(MSC_HEADER, CBUS_DATA, stCbusQueueInfo->ucData[1]);
490             // message length
491             pCbusFifo.lens = 3;
492             break;
493 
494         case MSC_WRITE_BURST: // 0x6C
495             // payload 1
496             //pCbusFifo.databuf[0] = _mdrv_mhl_CbusSetPacket(MSC_HEADER, CBUS_CONTROL, MSC_WRITE_BURST);
497             // payload 2 ~ 17
498             for(uctemp =0; uctemp <stCbusQueueInfo->ucLength; uctemp++) // offset packet + the maxi 16 packets
499             {
500                 pCbusFifo.databuf[uctemp +1] = _mdrv_mhl_CbusSetPacket(MSC_HEADER, CBUS_DATA, stCbusQueueInfo->ucData[uctemp]);
501             }
502             // EOF
503             pCbusFifo.databuf[stCbusQueueInfo->ucLength +1] = _mdrv_mhl_CbusSetPacket(MSC_HEADER, CBUS_CONTROL, MSC_EOF);
504             // message length
505             pCbusFifo.lens = stCbusQueueInfo->ucLength +2;
506             break;
507 
508         default:
509             bIndex = FALSE;
510             break;
511     }
512 
513     if(bIndex)
514     {
515         if(!mhal_mhl_CBusWrite(bECbusEnableFlag, &pCbusFifo))
516         {
517             return FALSE;
518         }
519     }
520 
521     return bIndex;
522 }
523 
524 //**************************************************************************
525 //  [Function Name]:
526 //                  _mdrv_mhl_GetFreeQueueIndex()
527 //  [Description]
528 //
529 //  [Arguments]:
530 //
531 //  [Return]:
532 //
533 //**************************************************************************
_mdrv_mhl_GetFreeQueueIndex(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate)534 MS_U8 _mdrv_mhl_GetFreeQueueIndex(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate)
535 {
536     MS_U8 uctemp = 0;
537     MS_U8 ucQueueIndex = 0;
538 
539     for(uctemp = 0; uctemp <(MHL_CBUS_TOTAL_QUEUE_NUM -1); uctemp++)
540     {
541         ucQueueIndex = (pMHLResourcePrivate->ucCurrentQueueIndex +uctemp +1) %(MHL_CBUS_TOTAL_QUEUE_NUM -1);
542 
543         if(pMHLResourcePrivate->stCbusQueueInfo[ucQueueIndex].ucQueueState == MHL_QUEUE_STATE_IDLE)
544         {
545             break;
546         }
547         else
548         {
549             ucQueueIndex = MHL_CBUS_TOTAL_QUEUE_NUM;
550         }
551     }
552 
553     if(ucQueueIndex < MHL_CBUS_TOTAL_QUEUE_NUM) // Have free queue
554     {
555         uctemp = (ucQueueIndex +MHL_CBUS_TOTAL_QUEUE_NUM -2) %(MHL_CBUS_TOTAL_QUEUE_NUM -1);
556 
557         if(pMHLResourcePrivate->stCbusQueueInfo[uctemp].ucQueueState == MHL_QUEUE_STATE_IDLE)
558         {
559             ucQueueIndex = uctemp;
560         }
561     }
562 
563     return ucQueueIndex;
564 }
565 
566 //**************************************************************************
567 //  [Function Name]:
568 //                  _mdrv_mhl_GetCbusQueueIndex()
569 //  [Description]:
570 //                  MHL Cbus get transmitting queue index
571 //  [Arguments]:
572 //
573 //  [Return]:
574 //
575 //**************************************************************************
_mdrv_mhl_GetCbusQueueIndex(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate)576 MS_U8 _mdrv_mhl_GetCbusQueueIndex(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate)
577 {
578     MS_U8 uctemp = 0;
579     MS_U8 ucQueueIndex = 0;
580 
581     // Check Rx queue have packet transmit success or not
582     if(pMHLResourcePrivate->stCbusQueueInfo[MHL_CBUS_RX_QUEUE_INDEX].ucQueueState != MHL_QUEUE_STATE_IDLE)
583     {
584         ucQueueIndex = MHL_CBUS_RX_QUEUE_INDEX;
585     }
586     else // Check Tx queue have packet transmit success or not, search start  from current index
587     {
588         for(uctemp = 0; uctemp <(MHL_CBUS_TOTAL_QUEUE_NUM -1); uctemp++)
589         {
590             ucQueueIndex = (pMHLResourcePrivate->ucCurrentQueueIndex +uctemp) %(MHL_CBUS_TOTAL_QUEUE_NUM -1);
591 
592             if(pMHLResourcePrivate->stCbusQueueInfo[ucQueueIndex].ucQueueState != MHL_QUEUE_STATE_IDLE)
593             {
594                 break;
595             }
596             else
597             {
598                 ucQueueIndex = MHL_CBUS_TOTAL_QUEUE_NUM;
599             }
600         }
601     }
602 
603     return ucQueueIndex;
604 }
605 
606 //**************************************************************************
607 //  [Function Name]:
608 //                  _mdrv_mhl_SetCbusTimerEvent()
609 //  [Description]:
610 //
611 //  [Arguments]:
612 //
613 //  [Return]:
614 //
615 //**************************************************************************
_mdrv_mhl_SetCbusTimerEvent(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate,MS_U8 ucTimerEvent,MS_U16 usTimerTick)616 void _mdrv_mhl_SetCbusTimerEvent(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate, MS_U8 ucTimerEvent, MS_U16 usTimerTick)
617 {
618     if(usTimerTick > 0)
619     {
620         pMHLResourcePrivate->stTimerEventInfo[ucTimerEvent].bEnableFlag = TRUE;
621 
622 #if(MHL_DEBUG_TIMER_EVENT)
623         MDRV_MHL_MSG_INFO("** MHL set timer event %d tick %d\r\n", ucTimerEvent, usTimerTick);
624 #endif
625     }
626 
627     pMHLResourcePrivate->stTimerEventInfo[ucTimerEvent].usTimerTick = usTimerTick;
628 }
629 
630 //**************************************************************************
631 //  [Function Name]:
632 //                  _mdrv_mhl_CbusRxQueueInsertMSG(BYTE subCmd, BYTE databuf)
633 //  [Description]
634 //                  MHL Cbus Reply MSC RCP or RAP into Queue
635 //  [Arguments]:
636 //                  subCmd: MSC subcommands
637 //                  databuf: command code
638 //  [Return]:
639 //                  TRUE: success
640 //                  FALSE: fail
641 //**************************************************************************
_mdrv_mhl_CbusRxQueueInsertMSG(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate,MS_U8 ucSubCommand,MS_U8 ucKeyCode)642 void _mdrv_mhl_CbusRxQueueInsertMSG(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate, MS_U8 ucSubCommand, MS_U8 ucKeyCode)
643 {
644     pMHLResourcePrivate->stCbusQueueInfo[MHL_CBUS_RX_QUEUE_INDEX].ucQueueState = MHL_QUEUE_STATE_PENDING;
645     pMHLResourcePrivate->stCbusQueueInfo[MHL_CBUS_RX_QUEUE_INDEX].ucLength = 2;
646     pMHLResourcePrivate->stCbusQueueInfo[MHL_CBUS_RX_QUEUE_INDEX].ucCommand = MSC_MSC_MSG;
647     pMHLResourcePrivate->stCbusQueueInfo[MHL_CBUS_RX_QUEUE_INDEX].ucData[0] = ucSubCommand;
648     pMHLResourcePrivate->stCbusQueueInfo[MHL_CBUS_RX_QUEUE_INDEX].ucData[1] = ucKeyCode;
649 }
650 
651 //**************************************************************************
652 //  [Function Name]:
653 //                  _mdrv_mhl_WriteBurstCheckSum()
654 //  [Description]
655 //
656 //  [Arguments]:
657 //
658 //  [Return]:
659 //
660 //**************************************************************************
_mdrv_mhl_WriteBurstCheckSum(MS_U8 * pData)661 MS_U8 _mdrv_mhl_WriteBurstCheckSum(MS_U8 *pData)
662 {
663     MS_U8 uctemp = 0;
664     MS_U8 ucCheckSum = 0;
665 
666     for(uctemp = 0; uctemp <MHL_MSC_SCRATCHPAD_SIZE; uctemp++)
667     {
668         ucCheckSum = ucCheckSum +pData[uctemp];
669     }
670 
671     ucCheckSum = (ucCheckSum ^0xFF) +1;
672 
673     return ucCheckSum;
674 }
675 
676 //**************************************************************************
677 //  [Function Name]:
678 //                  _mdrv_mhl_CheckSendCommand()
679 //  [Description]
680 //
681 //  [Arguments]:
682 //
683 //  [Return]:
684 //
685 //**************************************************************************
_mdrv_mhl_CheckSendCommand(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate)686 MS_BOOL _mdrv_mhl_CheckSendCommand(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate)
687 {
688     MS_BOOL bSendCommand = FALSE;
689     MS_BOOL bMHLPort = mhal_mhl_CheckInputPort(pMHLResourcePrivate->ucMHLSupportPath);
690 
691     if(bMHLPort && mhal_mhl_CheckPIPWindow()) // MHL port and scaler mux on
692     {
693         bSendCommand = TRUE;
694     }
695     else if(GET_MHL_CHIP_FLAG(pMHLResourcePrivate->ucChipCapability, MHL_CHIP_FORCE_SEND_COMMAND_FLAG) && GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_FORCE_SEND_COMMAND_FLAG))
696     {
697         bSendCommand = TRUE;
698     }
699 
700     return bSendCommand;
701 }
702 
703 //**************************************************************************
704 //  [Function Name]:
705 //                  _mdrv_mhl_GetRAPEnableFlag()
706 //  [Description]
707 //
708 //  [Arguments]:
709 //
710 //  [Return]:
711 //
712 //**************************************************************************
_mdrv_mhl_GetRAPEnableFlag(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate)713 MS_BOOL _mdrv_mhl_GetRAPEnableFlag(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate)
714 {
715     MS_BOOL bRAPEnable = FALSE;
716 
717     if(!mhal_mhl_CheckInputPort(pMHLResourcePrivate->ucMHLSupportPath))
718     {
719         bRAPEnable = TRUE;
720     }
721     else if(!mhal_mhl_CheckPIPWindow())
722     {
723         bRAPEnable = TRUE;
724     }
725     else if(pMHLResourcePrivate->stSignalStatusInfo.bSignalStableFlag)
726     {
727         bRAPEnable = TRUE;
728     }
729 
730     return bRAPEnable;
731 }
732 
733 //**************************************************************************
734 //  [Function Name]:
735 //                  _mdrv_mhl_CheckCbusModeChange()
736 //  [Description]
737 //
738 //  [Arguments]:
739 //
740 //  [Return]:
741 //
742 //**************************************************************************
_mdrv_mhl_CheckCbusModeChange(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate)743 MS_BOOL _mdrv_mhl_CheckCbusModeChange(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate)
744 {
745     MS_BOOL bNotCbusChange = TRUE;
746 
747     if(pMHLResourcePrivate->ucMSGData[1] == MHL_RAP_KEY_CBUS_MODE_UP)
748     {
749         bNotCbusChange = FALSE;
750 
751         pMHLResourcePrivate->ucECbusState = MHL_ECBUS_STATE_RECEIVE_MODE_UP;
752     }
753     else if(pMHLResourcePrivate->ucMSGData[1] == MHL_RAP_KEY_CBUS_MODE_DOWN)
754     {
755         bNotCbusChange = FALSE;
756 
757         pMHLResourcePrivate->ucECbusState = MHL_ECBUS_STATE_RECEIVE_MODE_DOWN;
758     }
759 
760     return bNotCbusChange;
761 }
762 
763 //**************************************************************************
764 //  [Function Name]:
765 //                  _mdrv_mhl_DTDPresentinEDID()
766 //  [Description]
767 //
768 //  [Arguments]:
769 //
770 //  [Return]:
771 //
772 //**************************************************************************
_mdrv_mhl_DTDPresentinEDID(MS_U8 * pData)773 MS_BOOL _mdrv_mhl_DTDPresentinEDID(MS_U8 *pData)
774 {
775     MS_BOOL bPresent = FALSE;
776     MS_U8 uctemp = 0;
777 
778     for(uctemp = 0; uctemp < 3; uctemp++)
779     {
780         if(pData[uctemp] > 0)
781         {
782             bPresent = TRUE;
783 
784             break;
785         }
786     }
787 
788     return bPresent;
789 }
790 
791 //**************************************************************************
792 //  [Function Name]:
793 //                  _mdrv_mhl_GetDTD3DTimingInformation()
794 //  [Description]
795 //
796 //  [Arguments]:
797 //
798 //  [Return]:
799 //
800 //**************************************************************************
_mdrv_mhl_GetDTD3DTimingInformation(MS_U8 * pData)801 MS_U8 _mdrv_mhl_GetDTD3DTimingInformation(MS_U8 *pData)
802 {
803     MS_BOOL bInterlace = ((pData[17] &BIT(7)) ?TRUE :FALSE);
804     MS_U8 ucIndex = 0;
805     MS_U16 usHActive = ((pData[4] &BMASK(7:4)) <<4) |pData[2];
806     MS_U16 usHBlank = ((pData[4] &BMASK(3:0)) <<8) |pData[3];
807     MS_U16 usVActive = ((pData[7] &BMASK(7:4)) <<4) |pData[5];
808     MS_U16 usVBlank = ((pData[7] &BMASK(3:0)) <<8) |pData[6];
809     MS_U16 usHTotal = usHActive +usHBlank;
810     MS_U16 usVTotal = usVActive +usVBlank;
811     MS_U16 usPixelClk = (pData[1] <<8) |pData[0];
812     MS_U32 ulFrequenct = 0;
813 
814     if((usHTotal > 0) && (usVTotal > 0))
815     {
816         ulFrequenct = (usPixelClk *100 /usHTotal) *1000 /usVTotal;
817 
818         if((usHActive == 1920) && (usVActive == 1080)) // 1920x1080p
819         {
820             if((ulFrequenct > 230) && (ulFrequenct < 245)) // 24Hz
821             {
822                 ucIndex = MHL_3D_PRESENT_VIC_1920x1080p24Hz;
823             }
824         }
825         else if((usHActive == 1920) && (usVActive == 540) && bInterlace) // 1920x1080i
826         {
827             if((ulFrequenct > 590) && (ulFrequenct < 610)) // 60Hz
828             {
829                 ucIndex = MHL_3D_PRESENT_VIC_1920x1080i60Hz;
830             }
831             else if((ulFrequenct > 490) && (ulFrequenct < 510)) // 50Hz
832             {
833                 ucIndex = MHL_3D_PRESENT_VIC_1920x1080i50Hz;
834             }
835         }
836         else if((usHActive == 1280) && (usVActive == 720)) // 1280x720p
837         {
838             if((ulFrequenct > 590) && (ulFrequenct < 610)) // 60Hz
839             {
840                 ucIndex = MHL_3D_PRESENT_VIC_1280x720p60Hz;
841             }
842             else if((ulFrequenct > 490) && (ulFrequenct < 510)) // 50Hz
843             {
844                 ucIndex = MHL_3D_PRESENT_VIC_1280x720p50Hz;
845             }
846         }
847     }
848 
849     return ucIndex;
850 }
851 
852 //**************************************************************************
853 //  [Function Name]:
854 //                  _mdrv_mhl_InsertDTD3DInformation()
855 //  [Description]
856 //
857 //  [Arguments]:
858 //
859 //  [Return]:
860 //
861 //**************************************************************************
_mdrv_mhl_InsertDTD3DInformation(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate,MS_U8 ucIndex,MS_U8 ucData)862 MS_U8 _mdrv_mhl_InsertDTD3DInformation(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate, MS_U8 ucIndex, MS_U8 ucData)
863 {
864     MS_U8 uctemp = 0;
865 
866     ucData = ((ucData &BMASK(6:5)) >> 4) |(ucData &BIT(0));
867 
868     switch(ucData)
869     {
870         case MHL_3D_DTD_STEREO_FIELD_SEQUENTIAL_RIGHT:
871             uctemp = MASKSET(uctemp, MHL_3D_FS_SUPPORT, MHL_3D_SUPPORT_MASK);
872             break;
873 
874         case MHL_3D_DTD_STEREO_FIELD_SEQUENTIAL_LEFT:
875             uctemp = MASKSET(uctemp, MHL_3D_FS_SUPPORT, MHL_3D_SUPPORT_MASK);
876             break;
877 
878         case MHL_3D_DTD_STEREO_2WAY_INTERLEAVED_RIGHT:
879             // No setting
880             break;
881 
882         case MHL_3D_DTD_STEREO_2WAY_INTERLEAVED_LEFT:
883             // No setting
884             break;
885 
886         case MHL_3D_DTD_STEREO_4WAY_INTERLEAVED:
887             // No setting
888             break;
889 
890         case MHL_3D_DTD_STEREO_SIDE_BY_SIDE_INTERLEAVED:
891             uctemp = MASKSET(uctemp, MHL_3D_LR_SUPPORT, MHL_3D_SUPPORT_MASK);
892             break;
893 
894         default: // MHL_3D_DTD_STEREO_NORMAL_DISPLAY
895 
896             break;
897     };
898 
899     pMHLResourcePrivate->uc3DInformationDTD[ucIndex] = uctemp;
900 
901     for(uctemp = 0, ucData = 0; uctemp < (ucIndex +1); uctemp++)
902     {
903         if(pMHLResourcePrivate->uc3DInformationDTD[uctemp] > 0)
904         {
905             ucData = uctemp +1;
906         }
907     }
908 
909     return ucData;
910 }
911 
912 //**************************************************************************
913 //  [Function Name]:
914 //                  _mdrv_mhl_CheckVIC3DStructureAll()
915 //  [Description]
916 //
917 //  [Arguments]:
918 //
919 //  [Return]:
920 //
921 //**************************************************************************
_mdrv_mhl_CheckVIC3DStructureAll(MS_U16 usData)922 MS_U8 _mdrv_mhl_CheckVIC3DStructureAll(MS_U16 usData)
923 {
924     MS_U8 uctemp = 0;
925 
926     if((usData &BIT(0)) == BIT(0)) // Support frame packing 3D formats
927     {
928         uctemp = MASKSET(uctemp, MHL_3D_FS_SUPPORT, MHL_3D_FS_SUPPORT);
929     }
930 
931     if((usData &BIT(6)) == BIT(6)) // Support top and bottom 3D formats
932     {
933         uctemp = MASKSET(uctemp, MHL_3D_TB_SUPPORT, MHL_3D_TB_SUPPORT);
934     }
935 
936     if((usData &BIT(8)) == BIT(8)) // Support side by side 3D formats
937     {
938         uctemp = MASKSET(uctemp, MHL_3D_LR_SUPPORT, MHL_3D_LR_SUPPORT);
939     }
940 
941     return uctemp;
942 }
943 
944 //**************************************************************************
945 //  [Function Name]:
946 //                  _mdrv_mhl_CheckVIC3DStructure()
947 //  [Description]
948 //
949 //  [Arguments]:
950 //
951 //  [Return]:
952 //
953 //**************************************************************************
_mdrv_mhl_CheckVIC3DStructure(MS_U8 ucData)954 MS_U8 _mdrv_mhl_CheckVIC3DStructure(MS_U8 ucData)
955 {
956     MS_U8 uctemp = 0;
957 
958     if(ucData == 0) // Support frame packing
959     {
960         uctemp = MASKSET(uctemp, MHL_3D_FS_SUPPORT, MHL_3D_FS_SUPPORT);
961     }
962     else if(ucData == 6) // Support top and bottom
963     {
964         uctemp = MASKSET(uctemp, MHL_3D_TB_SUPPORT, MHL_3D_TB_SUPPORT);
965     }
966     else if(ucData == 8) // Support side by side
967     {
968         uctemp = MASKSET(uctemp, MHL_3D_LR_SUPPORT, MHL_3D_LR_SUPPORT);
969     }
970 
971     return uctemp;
972 }
973 
974 //**************************************************************************
975 //  [Function Name]:
976 //                  _mdrv_mhl_InsertHighEndVICTable()
977 //  [Description]
978 //
979 //  [Arguments]:
980 //
981 //  [Return]:
982 //
983 //**************************************************************************
_mdrv_mhl_InsertHighEndVICTable(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate,MS_U8 ucVICCode)984 void _mdrv_mhl_InsertHighEndVICTable(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate, MS_U8 ucVICCode)
985 {
986     switch(ucVICCode)
987     {
988         case MHL_HEV_VIC_INDEX0:
989         case MHL_HEV_VIC_INDEX1:
990         case MHL_HEV_VIC_INDEX2:
991         case MHL_HEV_VIC_INDEX3:
992         case MHL_HEV_VIC_INDEX4:
993         case MHL_HEV_VIC_INDEX5:
994             pMHLResourcePrivate->usHighEndVICTable[pMHLResourcePrivate->ucHighEndVICTotalEntry] = ucVICCode;
995             pMHLResourcePrivate->ucHighEndVICTotalEntry++;
996             break;
997 
998         default:
999 
1000             break;
1001     };
1002 }
1003 
1004 //**************************************************************************
1005 //  [Function Name]:
1006 //                  _mdrv_mhl_ParsingVIC3DInformation()
1007 //  [Description]
1008 //
1009 //  [Arguments]:
1010 //
1011 //  [Return]:
1012 //
1013 //**************************************************************************
_mdrv_mhl_ParsingVIC3DInformation(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate,MS_U8 ucExtendLength,MS_U8 * pData)1014 MS_BOOL _mdrv_mhl_ParsingVIC3DInformation(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate, MS_U8 ucExtendLength, MS_U8 *pData)
1015 {
1016     MS_BOOL bVICParseFinish = TRUE;
1017     MS_BOOL b3DPresent = FALSE;
1018     MS_U8 uctemp = 0;
1019     MS_U8 ucIndex = 0;
1020     MS_U8 ucValue = 0;
1021     MS_U8 ucLength = 0;
1022     MS_U8 ucVSDBAddr = 0;
1023     MS_U8 ucVSDBLength = 0;
1024     MS_U8 uc3DMultiPresent = 0;
1025     MS_U8 ucVICTimingNum = 0;
1026     MS_U8 ucVICTiming[MHL_3D_VIC_INFORMATION_LENGTH] = {0};
1027     MS_U16 usMaskValue = 0;
1028 
1029     for(uctemp = 0; uctemp < MHL_3D_VIC_INFORMATION_LENGTH; uctemp++)
1030     {
1031         ucVICTiming[uctemp] = 0;
1032 
1033         pMHLResourcePrivate->uc3DInformationVIC[uctemp] = 0;
1034     }
1035 
1036     for(uctemp = 0; uctemp < ucExtendLength; uctemp++)
1037     {
1038         ucValue = (pData[uctemp] &BMASK(7:5)) >>5;
1039         ucLength = pData[uctemp] &BMASK(4:0);
1040 
1041         switch(ucValue)
1042         {
1043             case MHL_EDID_AUDIO_DATA_BLOCK_CODE:
1044                 MDRV_MHL_MSG_INFO("** MHL get audio data block length %d in port %c\r\n", ucLength, MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath));
1045                 break;
1046 
1047             case MHL_EDID_VIDEO_DATA_BLOCK_CODE:
1048                 MDRV_MHL_MSG_INFO("** MHL get video data block length %d in port %c\r\n", ucLength, MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath));
1049 
1050                 if(ucLength > MHL_3D_VIC_INFORMATION_LENGTH)
1051                 {
1052                     ucVICTimingNum = MHL_3D_VIC_INFORMATION_LENGTH;
1053                 }
1054                 else
1055                 {
1056                     ucVICTimingNum = ucLength;
1057                 }
1058 
1059                 for(ucIndex = 0; ucIndex <ucLength; ucIndex++)
1060                 {
1061                     if(ucIndex <ucVICTimingNum)
1062                     {
1063                         ucVICTiming[ucIndex] = pData[uctemp +ucIndex +1];
1064                     }
1065 
1066                     _mdrv_mhl_InsertHighEndVICTable(pMHLResourcePrivate, pData[uctemp +ucIndex +1]);
1067                 }
1068 
1069                 break;
1070 
1071             case MHL_EDID_VENDER_SPECIFIC_DATA_BLOCK_CODE:
1072                 MDRV_MHL_MSG_INFO("** MHL get vender specific data block length %d in port %c\r\n", ucLength, MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath));
1073 
1074                 ucVSDBAddr = uctemp;
1075 
1076                 bVICParseFinish = FALSE;
1077 
1078                 break;
1079 
1080             case MHL_EDID_SPEAKER_ALLOCATION_DATA_BLOCK_CODE:
1081                 MDRV_MHL_MSG_INFO("** MHL get speaker allocation data block length %d in port %c\r\n", ucLength, MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath));
1082                 break;
1083 
1084             case MHL_EDID_VESA_DTC_DATA_BLOCK_CODE:
1085                 MDRV_MHL_MSG_INFO("** MHL get VESA DTC data block length %d in port %c\r\n", ucLength, MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath));
1086                 break;
1087 
1088             case MHL_EDID_USE_EXTENDED_TAG_BLOCK_CODE:
1089                 MDRV_MHL_MSG_INFO("** MHL get use extended tag length %d in port %c\r\n", ucLength, MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath));
1090                 break;
1091 
1092             default:
1093 
1094                 break;
1095         };
1096 
1097         uctemp = uctemp +ucLength;
1098     }
1099 
1100     ucIndex = MHL_VIC_PARSING_START;
1101     ucVSDBLength = ucVSDBAddr +1;
1102 
1103     while(!bVICParseFinish)
1104     {
1105         ucValue = pData[ucVSDBAddr];
1106 
1107         if(ucVSDBAddr > ucVSDBLength) // Check total length
1108         {
1109             ucIndex = MHL_VIC_PARSING_FINISH;
1110         }
1111 
1112         switch(ucIndex)
1113         {
1114             case MHL_VIC_PARSING_START:
1115                 ucVSDBLength = pData[ucVSDBAddr] &BMASK(4:0);
1116 
1117                 if(ucVSDBLength < 8) // HDMI_Video_Present absent, no 3D information
1118                 {
1119                     ucIndex = MHL_VIC_PARSING_FINISH;
1120                 }
1121                 else
1122                 {
1123                     ucVSDBAddr = ucVSDBAddr +8;
1124 
1125                     ucIndex = MHL_VIC_PARSING_CHECK_HDMI_VIDEO_PRESENT;
1126                 }
1127 
1128                 ucVSDBLength = ucVSDBAddr +ucVSDBLength;
1129 
1130                 break;
1131 
1132             case MHL_VIC_PARSING_CHECK_HDMI_VIDEO_PRESENT:
1133                 if((ucValue &BIT(5)) != BIT(5)) // HDMI_Video_Present absent, no 3D information
1134                 {
1135                     ucIndex = MHL_VIC_PARSING_FINISH;
1136                 }
1137                 else
1138                 {
1139                     ucIndex = MHL_VIC_PARSING_CHECK_3D_PRESENT;
1140 
1141                     if((ucValue &BIT(7)) != BIT(7)) // Latency_Fields_Present absent, no video and audio latency and no interlaced video and audio latency
1142                     {
1143                         ucVSDBAddr++;
1144                     }
1145                     else
1146                     {
1147                         if((ucValue &BIT(6)) != BIT(6)) // I_Latency_Fields_Present absent, no video and audio latency
1148                         {
1149                             ucVSDBAddr = ucVSDBAddr +3;
1150                         }
1151                         else
1152                         {
1153                             ucVSDBAddr = ucVSDBAddr +5;
1154                         }
1155                     }
1156                 }
1157 
1158                 break;
1159 
1160             case MHL_VIC_PARSING_CHECK_3D_PRESENT:
1161                 if((ucValue &BIT(7)) != BIT(7)) // 3D_Present absent, no 3D information
1162                 {
1163                     ucIndex = MHL_VIC_PARSING_FINISH;
1164                 }
1165                 else
1166                 {
1167                     b3DPresent = TRUE;
1168                     uc3DMultiPresent = (ucValue &BMASK(6:5)) >> 5;
1169 
1170                     if(uc3DMultiPresent == 0)
1171                     {
1172                         ucIndex = MHL_VIC_PARSING_3D_MULTI_PRESENT_00;
1173                     }
1174                     else if(uc3DMultiPresent == 3) // Reserved for future use
1175                     {
1176                         ucIndex = MHL_VIC_PARSING_FINISH;
1177                     }
1178                     else
1179                     {
1180                         ucIndex = MHL_VIC_PARSING_CHECK_HDMI_VIC;
1181 
1182                         ucVSDBAddr++;
1183                     }
1184                 }
1185 
1186                 break;
1187 
1188             case MHL_VIC_PARSING_CHECK_HDMI_VIC:
1189                 ucLength = (ucValue &BMASK(7:5)) >> 5;
1190 
1191                 ucVSDBAddr = ucVSDBAddr +ucLength +1;
1192 
1193                 if(uc3DMultiPresent == 1)
1194                 {
1195                     ucIndex = MHL_VIC_PARSING_3D_MULTI_PRESENT_01;
1196                 }
1197                 else // uc3DMultiPresent = 2
1198                 {
1199                     ucIndex = MHL_VIC_PARSING_3D_MULTI_PRESENT_10;
1200                 }
1201 
1202                 ucLength = ucVSDBAddr +(ucValue &BMASK(4:0)) -1; // HDMI_3D_LEN
1203 
1204                 break;
1205 
1206             case MHL_VIC_PARSING_3D_MULTI_PRESENT_00:
1207                 ucIndex = MHL_VIC_PARSING_CHECK_3D_PRESENT_TIMING;
1208 
1209                 break;
1210 
1211             case MHL_VIC_PARSING_3D_MULTI_PRESENT_01:
1212                 ucValue = _mdrv_mhl_CheckVIC3DStructureAll((pData[ucVSDBAddr +1] |(pData[ucVSDBAddr] << 8)));
1213 
1214                 for(uctemp = 0; uctemp <ucVICTimingNum; uctemp++)
1215                 {
1216                     pMHLResourcePrivate->uc3DInformationVIC[uctemp] = ucValue;
1217                 }
1218 
1219                 ucIndex = MHL_VIC_PARSING_CHECK_3D_PRESENT_TIMING;
1220 
1221                 break;
1222 
1223             case MHL_VIC_PARSING_3D_MULTI_PRESENT_10:
1224                 ucValue = _mdrv_mhl_CheckVIC3DStructureAll((pData[ucVSDBAddr +1] |(pData[ucVSDBAddr] << 8)));
1225 
1226                 usMaskValue = pData[ucVSDBAddr +3] |(pData[ucVSDBAddr +2] << 8);
1227 
1228                 for(uctemp = 0; uctemp <ucVICTimingNum; uctemp++)
1229                 {
1230                     if((usMaskValue &BIT(uctemp)) == BIT(uctemp))
1231                     {
1232                         pMHLResourcePrivate->uc3DInformationVIC[uctemp] = ucValue;
1233                     }
1234                 }
1235 
1236                 ucVSDBAddr = ucVSDBAddr +4;
1237 
1238                 ucIndex = MHL_VIC_PARSING_CHECK_3D_STRUCTURE;
1239 
1240                 break;
1241 
1242             case MHL_VIC_PARSING_CHECK_3D_STRUCTURE:
1243                 if(ucVSDBAddr > ucLength) // No 3D sturcture
1244                 {
1245                     ucIndex = MHL_VIC_PARSING_CHECK_3D_PRESENT_TIMING;
1246                 }
1247                 else
1248                 {
1249                     uctemp = (ucValue &BMASK(7:4)) >> 4;
1250                     ucValue = ucValue &BMASK(3:0);
1251 
1252                     pMHLResourcePrivate->uc3DInformationVIC[uctemp] = _mdrv_mhl_CheckVIC3DStructure(ucValue);
1253 
1254                     if(ucValue < 8) // Only 2D_VIC_Order and 3D_Structure, 1 byte
1255                     {
1256                         ucVSDBAddr++;
1257                     }
1258                     else // Add 3D_Detail, 2 byte
1259                     {
1260                         ucVSDBAddr = ucVSDBAddr +2;
1261                     }
1262                 }
1263 
1264                 break;
1265 
1266             case MHL_VIC_PARSING_CHECK_3D_PRESENT_TIMING:
1267                 for(uctemp = 0; uctemp <ucVICTimingNum; uctemp++)
1268                 {
1269                     ucValue = pMHLResourcePrivate->uc3DInformationVIC[uctemp];
1270 
1271                     switch(ucVICTiming[uctemp])
1272                     {
1273                         case MHL_3D_PRESENT_VIC_1920x1080p24Hz: // Support frame packing with top and bottom
1274                         case MHL_3D_PRESENT_VIC_1280x720p60Hz: // Support frame packing with top and bottom
1275                         case MHL_3D_PRESENT_VIC_1280x720p50Hz: // Support frame packing with top and bottom
1276                             ucValue = MASKSET(ucValue, (MHL_3D_FS_SUPPORT |MHL_3D_TB_SUPPORT), (MHL_3D_FS_SUPPORT |MHL_3D_TB_SUPPORT));
1277                             pMHLResourcePrivate->uc3DInformationVIC[uctemp] = ucValue;
1278 
1279                             break;
1280 
1281                         case MHL_3D_PRESENT_VIC_1920x1080i60Hz: // Support side by side
1282                         case MHL_3D_PRESENT_VIC_1920x1080i50Hz: // Support side by side
1283                             ucValue = MASKSET(ucValue, MHL_3D_LR_SUPPORT, MHL_3D_LR_SUPPORT);
1284                             pMHLResourcePrivate->uc3DInformationVIC[uctemp] = ucValue;
1285 
1286                             break;
1287 
1288                         default:
1289 
1290                             break;
1291                     };
1292                 }
1293 
1294                 ucIndex = MHL_VIC_PARSING_FINISH;
1295 
1296                 break;
1297 
1298             case MHL_VIC_PARSING_FINISH:
1299                 bVICParseFinish = TRUE;
1300 
1301                 break;
1302 
1303             default:
1304 
1305                 break;
1306         };
1307     }
1308 
1309     for(uctemp = 0, ucValue = 0; uctemp < MHL_3D_VIC_INFORMATION_LENGTH; uctemp++)
1310     {
1311         if(pMHLResourcePrivate->uc3DInformationVIC[uctemp] > 0)
1312         {
1313             ucValue = uctemp +1;
1314         }
1315     }
1316 
1317     pMHLResourcePrivate->uc3DTotalEntryVIC = ucValue;
1318 
1319     return b3DPresent;
1320 }
1321 
1322 //**************************************************************************
1323 //  [Function Name]:
1324 //                  _mdrv_mhl_InsertVCInformation()
1325 //  [Description]:
1326 //
1327 //  [Arguments]:
1328 //
1329 //  [Return]:
1330 //
1331 //**************************************************************************
_mdrv_mhl_InsertVCInformation(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate,MS_BOOL bReceiveVC,MS_U8 ucVCNumber,MS_U8 ucVCFeatureID,MS_U8 ucVCSlotSize)1332 void _mdrv_mhl_InsertVCInformation(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate, MS_BOOL bReceiveVC, MS_U8 ucVCNumber, MS_U8 ucVCFeatureID, MS_U8 ucVCSlotSize)
1333 {
1334     MS_BOOL bFindVC = FALSE;
1335     MS_U8 uctemp = 0;
1336     MS_U8 ucTargetVC = MHL_VIRTUAL_CHANNEL_LENGTH;
1337     MS_U8 ucTotalTimeSlot = 0;
1338     MS_U8 ucResponseCode = MHL_VC_RESPONSE_ACCEPT;
1339 
1340     if(ucVCFeatureID >= MHL_VC_FEATURE_ID_END) // Invalid feature ID
1341     {
1342         ucResponseCode = MHL_VC_RESPONSE_REJECT_FEATURE_ID;
1343     }
1344     else if((ucVCFeatureID == MHL_VC_FEATURE_ID_EMSC) && (ucVCSlotSize != MHL_EMSC_TIME_SLOT_DEFAULT))
1345     {
1346         ucResponseCode = MHL_VC_RESPONSE_REJECT_CHANNEL_SIZE;
1347     }
1348 
1349     for(uctemp = 0; uctemp <MHL_VIRTUAL_CHANNEL_LENGTH; uctemp++)
1350     {
1351         if(!bFindVC)
1352         {
1353             if(pMHLResourcePrivate->stVirtualChannelInfo[uctemp].ucVCNumber == ucVCNumber) // VC present, information change
1354             {
1355                 ucTargetVC = uctemp;
1356 
1357                 bFindVC = TRUE;
1358             }
1359             else if(pMHLResourcePrivate->stVirtualChannelInfo[uctemp].ucVCNumber == 0) // VC absent, insert new information
1360             {
1361                 ucTargetVC = uctemp;
1362 
1363                 pMHLResourcePrivate->stVirtualChannelInfo[ucTargetVC].ucVCNumber = ucVCNumber;
1364                 pMHLResourcePrivate->stVirtualChannelInfo[ucTargetVC].ucVCFeatureID = ucVCFeatureID;
1365 
1366                 break;
1367             }
1368         }
1369 
1370         ucTotalTimeSlot = ucTotalTimeSlot +pMHLResourcePrivate->stVirtualChannelInfo[uctemp].ucVCSlotSize;
1371     }
1372 
1373     if(ucTargetVC < MHL_VIRTUAL_CHANNEL_LENGTH) // Can insert new VC information
1374     {
1375         pMHLResourcePrivate->stVirtualChannelInfo[ucTargetVC].bVCConfirm = TRUE;
1376 
1377         if(pMHLResourcePrivate->stVirtualChannelInfo[ucTargetVC].ucVCFeatureID != ucVCFeatureID) // Same VC number, but different feature ID
1378         {
1379             ucResponseCode = MHL_VC_RESPONSE_REJECT_NUMBER;
1380         }
1381         else if(ucTotalTimeSlot +ucVCSlotSize > MHL_ECBUS_S_TIME_SLOT_TOTAL -1) // Time slot not enough
1382         {
1383             ucResponseCode = MHL_VC_RESPONSE_REJECT_CHANNEL_SIZE;
1384         }
1385         else
1386         {
1387             if(bFindVC)
1388             {
1389                 pMHLResourcePrivate->stVirtualChannelInfo[ucTargetVC].ucVCResponseCode = pMHLResourcePrivate->stVirtualChannelInfo[ucTargetVC].ucVCSlotSize;
1390             }
1391 
1392             pMHLResourcePrivate->stVirtualChannelInfo[ucTargetVC].ucVCSlotSize = ucVCSlotSize;
1393         }
1394 
1395         if(bReceiveVC)
1396         {
1397             pMHLResourcePrivate->stVirtualChannelInfo[ucTargetVC].ucVCResponseCode = ucResponseCode;
1398         }
1399     }
1400     else // Virtual channel length is too small
1401     {
1402         MDRV_MHL_MSG_INFO("** MHL virtual channel length too small port %c\r\n", MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath));
1403     }
1404 }
1405 
1406 //**************************************************************************
1407 //  [Function Name]:
1408 //                  _mdrv_mhl_CheckVCInformation()
1409 //  [Description]:
1410 //
1411 //  [Arguments]:
1412 //
1413 //  [Return]:
1414 //
1415 //**************************************************************************
_mdrv_mhl_CheckVCInformation(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate,MS_U8 ucVCNumber,MS_U8 ucVCFeatureID,MS_U8 ucResponseCode)1416 void _mdrv_mhl_CheckVCInformation(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate, MS_U8 ucVCNumber, MS_U8 ucVCFeatureID, MS_U8 ucResponseCode)
1417 {
1418     MS_U8 uctemp = 0;
1419     MS_U8 ucTargetVC = MHL_VIRTUAL_CHANNEL_LENGTH;
1420 
1421     for(uctemp = 0; uctemp <MHL_VIRTUAL_CHANNEL_LENGTH; uctemp++)
1422     {
1423         if(pMHLResourcePrivate->stVirtualChannelInfo[uctemp].ucVCNumber == ucVCNumber) // VC present, information change
1424         {
1425             ucTargetVC = uctemp;
1426 
1427             if(pMHLResourcePrivate->stVirtualChannelInfo[uctemp].ucVCFeatureID != ucVCFeatureID)
1428             {
1429 
1430             }
1431 
1432             break;
1433         }
1434     }
1435 
1436     if(ucTargetVC < MHL_VIRTUAL_CHANNEL_LENGTH) // Can insert new VC information
1437     {
1438         if(ucResponseCode == MHL_VC_RESPONSE_REJECT_CHANNEL_SIZE)
1439         {
1440             pMHLResourcePrivate->stVirtualChannelInfo[ucTargetVC].ucVCSlotSize = pMHLResourcePrivate->stVirtualChannelInfo[ucTargetVC].ucVCResponseCode;
1441         }
1442         else if(ucResponseCode == MHL_VC_RESPONSE_REJECT_NUMBER)
1443         {
1444             pMHLResourcePrivate->stVirtualChannelInfo[ucTargetVC].ucVCSlotSize = 0;
1445         }
1446         else if(ucResponseCode == MHL_VC_RESPONSE_REJECT_FEATURE_ID)
1447         {
1448             pMHLResourcePrivate->stVirtualChannelInfo[ucTargetVC].ucVCSlotSize = 0;
1449         }
1450 
1451         pMHLResourcePrivate->stVirtualChannelInfo[ucTargetVC].ucVCResponseCode = MHL_VC_RESPONSE_ACCEPT;
1452     }
1453 }
1454 
1455 //**************************************************************************
1456 //  [Function Name]:
1457 //                  _mdrv_mhl_ParsingEDIDfor3D()
1458 //  [Description]
1459 //
1460 //  [Arguments]:
1461 //
1462 //  [Return]:
1463 //
1464 //**************************************************************************
_mdrv_mhl_ParsingEDIDfor3D(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate,MS_U8 * pEdid)1465 void _mdrv_mhl_ParsingEDIDfor3D(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate, MS_U8 *pEdid)
1466 {
1467     MS_BOOL bDTDParseFinish = FALSE;
1468     MS_U8 uctemp = 0;
1469     MS_U8 ucValue = 0;
1470     MS_U8 ucIndex = 0;
1471     MS_U8 ucDTDTimingNum = 0;
1472     MS_U8 ucThirdDTDStart = 0;
1473     MS_U8 ucDTDTiming[MHL_3D_DTD_INFORMATION_LENGTH] = {0};
1474 
1475     if(pEdid != NULL)
1476     {
1477         // Parsing 3D DTD information Start
1478         if(_mdrv_mhl_DTDPresentinEDID(&pEdid[MHL_EDID_FIRST_DTD_START])) // Check first DTD
1479         {
1480             ucValue = _mdrv_mhl_InsertDTD3DInformation(pMHLResourcePrivate, MHL_3D_FIRST_DTD, pEdid[MHL_EDID_FIRST_DTD_START +MHL_EDID_DTD_LENGTH -1]);
1481 
1482             ucDTDTiming[MHL_3D_FIRST_DTD] = _mdrv_mhl_GetDTD3DTimingInformation(&pEdid[MHL_EDID_FIRST_DTD_START]);
1483         }
1484         else // First DTD absent
1485         {
1486             bDTDParseFinish = TRUE;
1487 
1488             ucDTDTimingNum = 0;
1489 
1490             MDRV_MHL_MSG_INFO("** MHL first DTD absent in port %c\r\n", MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath));
1491         }
1492 
1493         if(!bDTDParseFinish)
1494         {
1495             if(_mdrv_mhl_DTDPresentinEDID(&pEdid[MHL_EDID_SECOND_DTD_START])) // Check second DTD
1496             {
1497                 ucValue = _mdrv_mhl_InsertDTD3DInformation(pMHLResourcePrivate, MHL_3D_SECOND_DTD, pEdid[MHL_EDID_SECOND_DTD_START +MHL_EDID_DTD_LENGTH -1]);
1498 
1499                 ucDTDTiming[MHL_3D_SECOND_DTD] = _mdrv_mhl_GetDTD3DTimingInformation(&pEdid[MHL_EDID_SECOND_DTD_START]);
1500             }
1501             else    // Second DTD absent
1502             {
1503                 bDTDParseFinish = TRUE;
1504 
1505                 ucDTDTimingNum = 1;
1506 
1507                 MDRV_MHL_MSG_INFO("** MHL second DTD absent in port %c\r\n", MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath));
1508             }
1509         }
1510 
1511         if(pEdid[MHL_EDID_EXTENSION_FLAG] > 0) // Have extend EDID
1512         {
1513             ucThirdDTDStart = MHL_EDID_BLOCK_LENGTH +pEdid[MHL_EDID_RESERVED_DATA_BLOCK];
1514 
1515             MDRV_MHL_MSG_INFO("** MHL third DTD start at %x in port %c\r\n", ucThirdDTDStart, MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath));
1516 
1517             if(!bDTDParseFinish)
1518             {
1519                 for(uctemp = 0; uctemp <(MHL_3D_DTD_INFORMATION_LENGTH -2); uctemp++)
1520                 {
1521                     if(_mdrv_mhl_DTDPresentinEDID(&pEdid[ucThirdDTDStart +MHL_EDID_DTD_LENGTH *uctemp])) // Check others DTD
1522                     {
1523                         ucValue = _mdrv_mhl_InsertDTD3DInformation(pMHLResourcePrivate, MHL_3D_THIRD_DTD +uctemp, pEdid[ucThirdDTDStart +MHL_EDID_DTD_LENGTH *(uctemp +1) -1]);
1524 
1525                         ucDTDTiming[MHL_3D_THIRD_DTD +uctemp] = _mdrv_mhl_GetDTD3DTimingInformation(&pEdid[ucThirdDTDStart +MHL_EDID_DTD_LENGTH *uctemp]);
1526                     }
1527                     else    // Last DTD find
1528                     {
1529                         bDTDParseFinish = TRUE;
1530 
1531                         ucDTDTimingNum = uctemp +2;
1532 
1533                         MDRV_MHL_MSG_INFO("** MHL total have %d DTD in port %c\r\n", ucDTDTimingNum, MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath));
1534 
1535                         break;
1536                     }
1537                 }
1538             }
1539 
1540             // Parsing 3D VIC information Start
1541             if(ucThirdDTDStart > (MHL_EDID_RESERVED_DATA_BLOCK +2))
1542             {
1543                 if(_mdrv_mhl_ParsingVIC3DInformation(pMHLResourcePrivate, pEdid[MHL_EDID_RESERVED_DATA_BLOCK] -4, &pEdid[MHL_EDID_RESERVED_DATA_BLOCK +2]))
1544                 {
1545                     // 3D Present
1546                     for(uctemp = 0; uctemp <ucDTDTimingNum; uctemp++)
1547                     {
1548                         ucIndex = pMHLResourcePrivate->uc3DInformationDTD[uctemp];
1549 
1550                         switch(ucDTDTiming[uctemp])
1551                         {
1552                             case MHL_3D_PRESENT_VIC_1920x1080p24Hz: // Support frame packing with top and bottom
1553                             case MHL_3D_PRESENT_VIC_1280x720p60Hz: // Support frame packing with top and bottom
1554                             case MHL_3D_PRESENT_VIC_1280x720p50Hz: // Support frame packing with top and bottom
1555                                 ucIndex = MASKSET(ucIndex, (MHL_3D_FS_SUPPORT |MHL_3D_TB_SUPPORT), (MHL_3D_FS_SUPPORT |MHL_3D_TB_SUPPORT));
1556                                 pMHLResourcePrivate->uc3DInformationDTD[uctemp] = ucIndex;
1557 
1558                                 break;
1559 
1560                             case MHL_3D_PRESENT_VIC_1920x1080i60Hz: // Support side by side
1561                             case MHL_3D_PRESENT_VIC_1920x1080i50Hz: // Support side by side
1562                                 ucIndex = MASKSET(ucIndex, MHL_3D_LR_SUPPORT, MHL_3D_LR_SUPPORT);
1563                                 pMHLResourcePrivate->uc3DInformationDTD[uctemp] = ucIndex;
1564 
1565                                 break;
1566 
1567                             default:
1568 
1569                                 break;
1570                         };
1571 
1572                         if(ucIndex > 0)
1573                         {
1574                             ucValue = uctemp +1;
1575                         }
1576                     }
1577                 }
1578             }
1579         }
1580 
1581         // Parsing 3D DTD information End
1582         pMHLResourcePrivate->uc3DTotalEntryDTD = ucValue;
1583     }
1584 }
1585 
1586 //**************************************************************************
1587 //  [Function Name]:
1588 //                  _mdrv_mhl_SlotAllocationAlgorithm()
1589 //  [Description]
1590 //
1591 //  [Arguments]:
1592 //
1593 //  [Return]:
1594 //
1595 //**************************************************************************
_mdrv_mhl_SlotAllocationAlgorithm(MS_U8 ucChannelIndex,MS_U8 ucNValue,MS_U8 ucMValue,MS_U8 * pSlotAllocation)1596 void _mdrv_mhl_SlotAllocationAlgorithm(MS_U8 ucChannelIndex, MS_U8 ucNValue, MS_U8 ucMValue, MS_U8 *pSlotAllocation)
1597 {
1598     MS_U8 uctemp = 0;
1599     MS_U8 ucCounter = 0;
1600 
1601     for(uctemp = 0; uctemp <MHL_ECBUS_S_TIME_SLOT_TOTAL; uctemp++)
1602     {
1603         if(pSlotAllocation[uctemp] == MHL_CBUS_SLOT_NOT_ALLOCATE)
1604         {
1605             if(ucCounter >= ucNValue)
1606             {
1607                 pSlotAllocation[uctemp] = ucChannelIndex;
1608             }
1609 
1610             ucCounter = (ucCounter +ucNValue) %(ucNValue +ucMValue);
1611         }
1612     }
1613 }
1614 
1615 //**************************************************************************
1616 //  [Function Name]:
1617 //                  _mdrv_mhl_eCbusTimeSlotAllocation()
1618 //  [Description]
1619 //
1620 //  [Arguments]:
1621 //
1622 //  [Return]:
1623 //
1624 //**************************************************************************
_mdrv_mhl_eCbusTimeSlotAllocation(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate)1625 void _mdrv_mhl_eCbusTimeSlotAllocation(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate)
1626 {
1627     MS_U8 uctemp = 0;
1628     MS_U8 ucTimeSlotNumber = MHL_ECBUS_S_TIME_SLOT_TOTAL -1;
1629     MS_U8 ucSlotAllocation[MHL_ECBUS_S_TIME_SLOT_TOTAL];
1630     MS_U8 ucVirtualChannel[MHL_VIRTUAL_CHANNEL_LENGTH +2];
1631 
1632     for(uctemp = 0; uctemp <(MHL_VIRTUAL_CHANNEL_LENGTH +2); uctemp++)
1633     {
1634         ucVirtualChannel[uctemp] = 0;
1635     }
1636 
1637     for(uctemp = 0; uctemp <MHL_ECBUS_S_TIME_SLOT_TOTAL; uctemp++)
1638     {
1639         if(uctemp == 0)
1640         {
1641             ucSlotAllocation[uctemp] = 0;
1642         }
1643         else
1644         {
1645             ucSlotAllocation[uctemp] = MHL_CBUS_SLOT_NOT_ALLOCATE;
1646         }
1647     }
1648 
1649     ucVirtualChannel[0] = MHL_CBUS1_TIME_SLOT_DEFAULT;
1650 
1651     for(uctemp = 0; uctemp <MHL_VIRTUAL_CHANNEL_LENGTH; uctemp++)
1652     {
1653         if(pMHLResourcePrivate->stVirtualChannelInfo[uctemp].ucVCSlotSize == 0)
1654         {
1655             break;
1656         }
1657         else
1658         {
1659             ucVirtualChannel[uctemp +1] = pMHLResourcePrivate->stVirtualChannelInfo[uctemp].ucVCSlotSize;
1660             ucTimeSlotNumber = ucTimeSlotNumber -pMHLResourcePrivate->stVirtualChannelInfo[uctemp].ucVCSlotSize;
1661         }
1662     }
1663 
1664     ucVirtualChannel[uctemp +1] = ucTimeSlotNumber;
1665 
1666     for(uctemp = 0; uctemp <(MHL_VIRTUAL_CHANNEL_LENGTH +2); uctemp++)
1667     {
1668         MDRV_MHL_MSG_INFO("** MHL time slot assign %d\r\n", ucVirtualChannel[uctemp]);
1669     }
1670 
1671     ucTimeSlotNumber = MHL_ECBUS_S_TIME_SLOT_TOTAL -1;
1672 
1673     for(uctemp = MHL_VIRTUAL_CHANNEL_LENGTH +1; ucTimeSlotNumber > 0; uctemp--)
1674     {
1675         if(ucVirtualChannel[uctemp] > 0)
1676         {
1677             ucTimeSlotNumber = ucTimeSlotNumber -ucVirtualChannel[uctemp];
1678 
1679             _mdrv_mhl_SlotAllocationAlgorithm(uctemp, ucTimeSlotNumber, ucVirtualChannel[uctemp], ucSlotAllocation);
1680         }
1681     }
1682 
1683     for(uctemp = 0; uctemp <MHL_ECBUS_S_TIME_SLOT_TOTAL; uctemp++)
1684     {
1685         MDRV_MHL_MSG_INFO("** MHL time slot allocation %d\r\n", ucSlotAllocation[uctemp]);
1686     }
1687 }
1688 
1689 //**************************************************************************
1690 //  [Function Name]:
1691 //                  _mdrv_mhl_SortingVCInformation()
1692 //  [Description]:
1693 //
1694 //  [Arguments]:
1695 //
1696 //  [Return]:
1697 //
1698 //**************************************************************************
_mdrv_mhl_SortingVCInformation(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate,MS_BOOL bClearFlag)1699 void _mdrv_mhl_SortingVCInformation(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate, MS_BOOL bClearFlag)
1700 {
1701     MS_U8 uctemp = 0;
1702     MS_U8 ucIndex = 0;
1703     MS_U8 ucTargetVC = MHL_VIRTUAL_CHANNEL_LENGTH;
1704     stMHL_VIRTUAL_CHANNEL_INFO stVirtualChannelTemp = {FALSE, 0, 0, 0, 0};
1705 
1706     for(ucIndex = 0; ucIndex <(ucTargetVC -1); ucIndex++)
1707     {
1708         for(uctemp = 0; uctemp <(ucTargetVC -ucIndex -1); uctemp++)
1709         {
1710             if(pMHLResourcePrivate->stVirtualChannelInfo[uctemp +1].ucVCNumber == 0)
1711             {
1712                 ucTargetVC = uctemp +1;
1713 
1714                 break;
1715             }
1716             else
1717             {
1718                 if(pMHLResourcePrivate->stVirtualChannelInfo[uctemp].ucVCSlotSize == 0)
1719                 {
1720                     pMHLResourcePrivate->stVirtualChannelInfo[uctemp].ucVCNumber = 0xFF;
1721                 }
1722 
1723                 if(pMHLResourcePrivate->stVirtualChannelInfo[uctemp +1].ucVCNumber < pMHLResourcePrivate->stVirtualChannelInfo[uctemp].ucVCNumber)
1724                 {
1725                     // temp = n +1
1726                     stVirtualChannelTemp.bVCConfirm = pMHLResourcePrivate->stVirtualChannelInfo[uctemp +1].bVCConfirm;
1727                     stVirtualChannelTemp.ucVCFeatureID = pMHLResourcePrivate->stVirtualChannelInfo[uctemp +1].ucVCFeatureID;
1728                     stVirtualChannelTemp.ucVCNumber = pMHLResourcePrivate->stVirtualChannelInfo[uctemp +1].ucVCNumber;
1729                     stVirtualChannelTemp.ucVCResponseCode = pMHLResourcePrivate->stVirtualChannelInfo[uctemp +1].ucVCResponseCode;
1730                     stVirtualChannelTemp.ucVCSlotSize = pMHLResourcePrivate->stVirtualChannelInfo[uctemp +1].ucVCSlotSize;
1731                     // n +1 = n
1732                     pMHLResourcePrivate->stVirtualChannelInfo[uctemp +1].bVCConfirm = pMHLResourcePrivate->stVirtualChannelInfo[uctemp].bVCConfirm;
1733                     pMHLResourcePrivate->stVirtualChannelInfo[uctemp +1].ucVCFeatureID = pMHLResourcePrivate->stVirtualChannelInfo[uctemp].ucVCFeatureID;
1734                     pMHLResourcePrivate->stVirtualChannelInfo[uctemp +1].ucVCNumber = pMHLResourcePrivate->stVirtualChannelInfo[uctemp].ucVCNumber;
1735                     pMHLResourcePrivate->stVirtualChannelInfo[uctemp +1].ucVCResponseCode = pMHLResourcePrivate->stVirtualChannelInfo[uctemp].ucVCResponseCode;
1736                     pMHLResourcePrivate->stVirtualChannelInfo[uctemp +1].ucVCSlotSize = pMHLResourcePrivate->stVirtualChannelInfo[uctemp].ucVCSlotSize;
1737                     // n = temp
1738                     pMHLResourcePrivate->stVirtualChannelInfo[uctemp].bVCConfirm = stVirtualChannelTemp.bVCConfirm;
1739                     pMHLResourcePrivate->stVirtualChannelInfo[uctemp].ucVCFeatureID = stVirtualChannelTemp.ucVCFeatureID;
1740                     pMHLResourcePrivate->stVirtualChannelInfo[uctemp].ucVCNumber = stVirtualChannelTemp.ucVCNumber;
1741                     pMHLResourcePrivate->stVirtualChannelInfo[uctemp].ucVCResponseCode = stVirtualChannelTemp.ucVCResponseCode;
1742                     pMHLResourcePrivate->stVirtualChannelInfo[uctemp].ucVCSlotSize = stVirtualChannelTemp.ucVCSlotSize;
1743                 }
1744             }
1745         }
1746     }
1747 
1748     for(uctemp = 0; uctemp <MHL_VIRTUAL_CHANNEL_LENGTH; uctemp++)
1749     {
1750         if(pMHLResourcePrivate->stVirtualChannelInfo[uctemp].ucVCSlotSize == 0)
1751         {
1752             pMHLResourcePrivate->stVirtualChannelInfo[uctemp].ucVCNumber = 0;
1753         }
1754 
1755         if(bClearFlag)
1756         {
1757             pMHLResourcePrivate->stVirtualChannelInfo[uctemp].bVCConfirm = FALSE;
1758         }
1759 
1760         MDRV_MHL_MSG_INFO("** MHL VC sorting number %d\r\n", pMHLResourcePrivate->stVirtualChannelInfo[uctemp].ucVCNumber);
1761         MDRV_MHL_MSG_INFO("** MHL VC sorting slot %d\r\n", pMHLResourcePrivate->stVirtualChannelInfo[uctemp].ucVCSlotSize);
1762     }
1763 }
1764 
1765 //**************************************************************************
1766 //  [Function Name]:
1767 //                  _mdrv_mhl_CbusSendSetHPD()
1768 //  [Description]:
1769 //                  MHL Cbus set HPD state
1770 //  [Arguments]:
1771 //                  TRUE: SET_HPD
1772 //                  FALSE: CLR_HPD
1773 //  [Return]:
1774 //
1775 //**************************************************************************
_mdrv_mhl_CbusSendSetHPD(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate,MS_BOOL bSetHPDFlag)1776 void _mdrv_mhl_CbusSendSetHPD(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate, MS_BOOL bSetHPDFlag)
1777 {
1778     MS_U8 ucQueueIndex = _mdrv_mhl_GetFreeQueueIndex(pMHLResourcePrivate);
1779 
1780     if(ucQueueIndex < MHL_CBUS_TOTAL_QUEUE_NUM)
1781     {
1782         pMHLResourcePrivate->stCbusQueueInfo[ucQueueIndex].ucQueueState = MHL_QUEUE_STATE_PENDING;
1783         pMHLResourcePrivate->stCbusQueueInfo[ucQueueIndex].ucLength = 0;
1784         pMHLResourcePrivate->stCbusQueueInfo[ucQueueIndex].ucCommand = (bSetHPDFlag? MSC_SET_HPD : MSC_CLR_HPD);
1785 
1786         if(bSetHPDFlag)
1787         {
1788             SET_MHL_DISPLAY_FLAG(pMHLResourcePrivate->usDisplayIndex, MHL_CBUS_HPD_SET_FLAG);
1789             SET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_COMMUNICATE_BUSY_FLAG);
1790         }
1791         else
1792         {
1793             CLR_MHL_DISPLAY_FLAG(pMHLResourcePrivate->usDisplayIndex, MHL_CBUS_HPD_SET_FLAG);
1794             CLR_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_COMMUNICATE_BUSY_FLAG);
1795         }
1796     }
1797 }
1798 
1799 //**************************************************************************
1800 //  [Function Name]:
1801 //                  _mdrv_mhl_CbusWriteStatusOrSetInt(BYTE addr, BYTE val)
1802 //  [Description]:
1803 //                  MHL Cbus write status or set interrupt
1804 //  [Arguments]:
1805 //
1806 //  [Return]:
1807 //                  TRUE: Cbus message send successfully
1808 //                  FALSE: Cbus message send fail
1809 //**************************************************************************
_mdrv_mhl_CbusWriteStatusOrSetInt(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate,MS_U8 ucAddress,MS_U8 ucValue,MS_BOOL bExtended)1810 MS_BOOL _mdrv_mhl_CbusWriteStatusOrSetInt(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate, MS_U8 ucAddress, MS_U8 ucValue, MS_BOOL bExtended)
1811 {
1812     MS_BOOL bInsertFlag = FALSE;
1813     MS_U8 ucQueueIndex = _mdrv_mhl_GetFreeQueueIndex(pMHLResourcePrivate);
1814 
1815     if(ucQueueIndex < MHL_CBUS_TOTAL_QUEUE_NUM)
1816     {
1817         pMHLResourcePrivate->stCbusQueueInfo[ucQueueIndex].ucQueueState = MHL_QUEUE_STATE_PENDING;
1818         pMHLResourcePrivate->stCbusQueueInfo[ucQueueIndex].ucLength = 2;
1819         pMHLResourcePrivate->stCbusQueueInfo[ucQueueIndex].ucCommand = (bExtended? MSC_WRITE_XSTAT : MSC_WRITE_STAT_OR_SET_INT);
1820         pMHLResourcePrivate->stCbusQueueInfo[ucQueueIndex].ucData[0] = ucAddress;
1821         pMHLResourcePrivate->stCbusQueueInfo[ucQueueIndex].ucData[1] = ucValue;
1822 
1823         bInsertFlag = TRUE;
1824     }
1825 
1826     return bInsertFlag;
1827 }
1828 
1829 //**************************************************************************
1830 //  [Function Name]:
1831 //                  _mdrv_mhl_CbusSendSubMessage
1832 //  [Description]
1833 //                  MHL Cbus MSC Send RCP or RAP
1834 //  [Arguments]:
1835 //                  subCmd: MSC subcommands
1836 //                  databuf: command code
1837 //  [Return]:
1838 //                  TRUE: success
1839 //                  FALSE: fail
1840 //**************************************************************************
_mdrv_mhl_CbusSendSubMessage(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate,MS_U8 ucSubCommand,MS_U8 ucKeyCode,MS_BOOL bWaitReply)1841 MS_BOOL _mdrv_mhl_CbusSendSubMessage(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate, MS_U8 ucSubCommand, MS_U8 ucKeyCode, MS_BOOL bWaitReply)
1842 {
1843     MS_BOOL bInsertFlag = FALSE;
1844     MS_U8 ucQueueIndex = MHL_CBUS_TOTAL_QUEUE_NUM;
1845 
1846     if(!GET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_MSG_COMMAND_FLAG))
1847     {
1848         ucQueueIndex = _mdrv_mhl_GetFreeQueueIndex(pMHLResourcePrivate);
1849 
1850         if(ucQueueIndex < MHL_CBUS_TOTAL_QUEUE_NUM)
1851         {
1852             pMHLResourcePrivate->stCbusQueueInfo[ucQueueIndex].ucQueueState = MHL_QUEUE_STATE_PENDING;
1853             pMHLResourcePrivate->stCbusQueueInfo[ucQueueIndex].ucLength = 2;
1854             pMHLResourcePrivate->stCbusQueueInfo[ucQueueIndex].ucCommand = MSC_MSC_MSG;
1855             pMHLResourcePrivate->stCbusQueueInfo[ucQueueIndex].ucData[0] = ucSubCommand;
1856             pMHLResourcePrivate->stCbusQueueInfo[ucQueueIndex].ucData[1] = ucKeyCode;
1857 
1858             bInsertFlag = TRUE;
1859         }
1860 
1861         if(bWaitReply && bInsertFlag)
1862         {
1863             _mdrv_mhl_SetCbusTimerEvent(pMHLResourcePrivate, MHL_TIMER_EVENT_WAIT_MSG_RESPONSE, MHL_MSG_WAIT_RESPONSE_TIME);
1864 
1865             SET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_MSG_COMMAND_FLAG);
1866         }
1867     }
1868 
1869     return bInsertFlag;
1870 }
1871 
1872 //**************************************************************************
1873 //  [Function Name]:
1874 //                  _mdrv_mhl_CbusSendGetVenderID()
1875 //  [Description]:
1876 //
1877 //  [Arguments]:
1878 //
1879 //  [Return]:
1880 //                  TRUE: Cbus message send successfully
1881 //                  FALSE: Cbus message send fail
1882 //**************************************************************************
_mdrv_mhl_CbusSendGetVenderID(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate)1883 MS_BOOL _mdrv_mhl_CbusSendGetVenderID(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate)
1884 {
1885     MS_BOOL bInsertFlag = FALSE;
1886     MS_U8 ucQueueIndex = _mdrv_mhl_GetFreeQueueIndex(pMHLResourcePrivate);
1887 
1888     if(ucQueueIndex < MHL_CBUS_TOTAL_QUEUE_NUM)
1889     {
1890         pMHLResourcePrivate->stCbusQueueInfo[ucQueueIndex].ucQueueState = MHL_QUEUE_STATE_PENDING;
1891         pMHLResourcePrivate->stCbusQueueInfo[ucQueueIndex].ucLength = 0;
1892         pMHLResourcePrivate->stCbusQueueInfo[ucQueueIndex].ucCommand = MSC_GET_VENDOR_ID;
1893 
1894         bInsertFlag = TRUE;
1895     }
1896 
1897     return bInsertFlag;
1898 }
1899 
1900 //**************************************************************************
1901 //  [Function Name]:
1902 //                  _mdrv_mhl_CbusReadDeviceCapability()
1903 //  [Description]:
1904 //
1905 //  [Arguments]:
1906 //
1907 //  [Return]:
1908 //                  TRUE: Cbus message send successfully
1909 //                  FALSE: Cbus message send fail
1910 //**************************************************************************
_mdrv_mhl_CbusReadDeviceCapability(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate,MS_U8 ucBitNumber,MS_BOOL bExtended)1911 MS_BOOL _mdrv_mhl_CbusReadDeviceCapability(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate, MS_U8 ucBitNumber, MS_BOOL bExtended)
1912 {
1913     MS_BOOL bInsertFlag = FALSE;
1914     MS_U8 ucQueueIndex = _mdrv_mhl_GetFreeQueueIndex(pMHLResourcePrivate);
1915 
1916     if(ucQueueIndex < MHL_CBUS_TOTAL_QUEUE_NUM)
1917     {
1918         pMHLResourcePrivate->stCbusQueueInfo[ucQueueIndex].ucQueueState = MHL_QUEUE_STATE_PENDING;
1919         pMHLResourcePrivate->stCbusQueueInfo[ucQueueIndex].ucLength = 1;
1920         pMHLResourcePrivate->stCbusQueueInfo[ucQueueIndex].ucCommand = (bExtended? MSC_READ_XDEVCAP : MSC_READ_DEVCAP);
1921         pMHLResourcePrivate->stCbusQueueInfo[ucQueueIndex].ucData[0] = (bExtended? (0x80 +ucBitNumber) : ucBitNumber);
1922 
1923         bInsertFlag = TRUE;
1924     }
1925 
1926     return bInsertFlag;
1927 }
1928 
1929 //**************************************************************************
1930 //  [Function Name]:
1931 //                  _mdrv_mhl_CbusSendWriteBurst()
1932 //  [Description]:
1933 //
1934 //  [Arguments]:
1935 //
1936 //  [Return]:
1937 //                  TRUE: Cbus message send successfully
1938 //                  FALSE: Cbus message send fail
1939 //**************************************************************************
_mdrv_mhl_CbusSendWriteBurst(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate,MS_U8 ucAddress,MS_U8 ucLength,MS_U8 * ucData)1940 MS_BOOL _mdrv_mhl_CbusSendWriteBurst(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate, MS_U8 ucAddress, MS_U8 ucLength, MS_U8 *ucData)
1941 {
1942     MS_BOOL bInsertFlag = FALSE;
1943     MS_U8 uctemp = 0;
1944     MS_U8 ucQueueIndex = _mdrv_mhl_GetFreeQueueIndex(pMHLResourcePrivate);
1945 
1946     if(ucQueueIndex < MHL_CBUS_TOTAL_QUEUE_NUM)
1947     {
1948         pMHLResourcePrivate->stCbusQueueInfo[ucQueueIndex].ucQueueState = MHL_QUEUE_STATE_PENDING;
1949         pMHLResourcePrivate->stCbusQueueInfo[ucQueueIndex].ucLength = ucLength +1;
1950         pMHLResourcePrivate->stCbusQueueInfo[ucQueueIndex].ucCommand = MSC_WRITE_BURST;
1951         pMHLResourcePrivate->stCbusQueueInfo[ucQueueIndex].ucData[0] = ucAddress;
1952 
1953         for(uctemp = 0; uctemp < ucLength; uctemp++)
1954         {
1955             pMHLResourcePrivate->stCbusQueueInfo[ucQueueIndex].ucData[uctemp +1] = ucData[uctemp];
1956         }
1957 
1958         bInsertFlag = TRUE;
1959     }
1960 
1961     return bInsertFlag;
1962 }
1963 
1964 //**************************************************************************
1965 //  [Function Name]:
1966 //                  _mdrv_mhl_CbusSendPathEnable()
1967 //  [Description]:
1968 //                  MHL Cbus set path enable
1969 //  [Arguments]:
1970 //                  TRUE: Enable
1971 //                  FALSE: Disable
1972 //  [Return]:
1973 //
1974 //**************************************************************************
_mdrv_mhl_CbusSendPathEnable(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate,MS_BOOL bEnableFlag)1975 void _mdrv_mhl_CbusSendPathEnable(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate, MS_BOOL bEnableFlag)
1976 {
1977     MS_BOOL bInsertFlag = _mdrv_mhl_CbusWriteStatusOrSetInt(pMHLResourcePrivate, 0x31, (bEnableFlag ? BIT(3) : 0), FALSE);
1978 
1979     if(bInsertFlag)
1980     {
1981         mhal_mhl_Cbus_SetPathEn(bEnableFlag);
1982 
1983         if(bEnableFlag)
1984         {
1985             SET_MHL_DISPLAY_FLAG(pMHLResourcePrivate->usDisplayIndex, MHL_CBUS_PATH_EN_FLAG);
1986         }
1987         else
1988         {
1989             CLR_MHL_DISPLAY_FLAG(pMHLResourcePrivate->usDisplayIndex, MHL_CBUS_PATH_EN_FLAG);
1990         }
1991     }
1992 }
1993 
1994 //**************************************************************************
1995 //  [Function Name]:
1996 //                  _mdrv_mhl_CbusSendDevcapReady()
1997 //  [Description]:
1998 //                  MHL Cbus set capbility ready
1999 //  [Arguments]:
2000 //                  TRUE: Enable
2001 //                  FALSE: Disable
2002 //  [Return]:
2003 //
2004 //**************************************************************************
_mdrv_mhl_CbusSendDevcapReady(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate)2005 void _mdrv_mhl_CbusSendDevcapReady(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate)
2006 {
2007     MS_BOOL bInsertFlag = FALSE;
2008     MS_U8 ucDevcapValue = BIT(0);
2009 
2010     if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CBUS_ENHANCE_FLAG))
2011     {
2012         ucDevcapValue = ucDevcapValue| BIT(1);
2013     }
2014 
2015     bInsertFlag = _mdrv_mhl_CbusWriteStatusOrSetInt(pMHLResourcePrivate, 0x30, ucDevcapValue, FALSE);
2016 
2017     if(bInsertFlag)
2018     {
2019         SET_MHL_DISPLAY_FLAG(pMHLResourcePrivate->usDisplayIndex, MHL_CBUS_DEVCAP_READY_FLAG);
2020     }
2021     else
2022     {
2023         CLR_MHL_DISPLAY_FLAG(pMHLResourcePrivate->usDisplayIndex, MHL_CBUS_DEVCAP_READY_FLAG);
2024     }
2025 }
2026 
2027 //**************************************************************************
2028 //  [Function Name]:
2029 //                  _mdrv_mhl_CbusSendDevcapChange()
2030 //  [Description]:
2031 //                  MHL Cbus set capbility change
2032 //  [Arguments]:
2033 //                  TRUE: Enable
2034 //                  FALSE: Disable
2035 //  [Return]:
2036 //
2037 //**************************************************************************
_mdrv_mhl_CbusSendDevcapChange(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate)2038 void _mdrv_mhl_CbusSendDevcapChange(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate)
2039 {
2040     MS_BOOL bInsertFlag = _mdrv_mhl_CbusWriteStatusOrSetInt(pMHLResourcePrivate, 0x20, BIT(0), FALSE);
2041 
2042     if(bInsertFlag)
2043     {
2044         SET_MHL_DISPLAY_FLAG(pMHLResourcePrivate->usDisplayIndex, MHL_CBUS_DEVCAP_CHANGE_FLAG);
2045     }
2046     else
2047     {
2048         CLR_MHL_DISPLAY_FLAG(pMHLResourcePrivate->usDisplayIndex, MHL_CBUS_DEVCAP_CHANGE_FLAG);
2049     }
2050 }
2051 
2052 //**************************************************************************
2053 //  [Function Name]:
2054 //                  _mdrv_mhl_CbusSendVersionCode()
2055 //  [Description]:
2056 //
2057 //  [Arguments]:
2058 //
2059 //  [Return]:
2060 //
2061 //**************************************************************************
_mdrv_mhl_CbusSendVersionCode(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate)2062 void _mdrv_mhl_CbusSendVersionCode(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate)
2063 {
2064     MS_BOOL bInsertFlag = _mdrv_mhl_CbusWriteStatusOrSetInt(pMHLResourcePrivate, 0x32, pMHLResourcePrivate->ucDeviceCapabilityTable[MHL_CBUS_VERSION], FALSE);
2065 
2066     if(bInsertFlag)
2067     {
2068         SET_MHL_DISPLAY_FLAG(pMHLResourcePrivate->usDisplayIndex, MHL_CBUS_VERSION_CODE_FLAG);
2069     }
2070     else
2071     {
2072         CLR_MHL_DISPLAY_FLAG(pMHLResourcePrivate->usDisplayIndex, MHL_CBUS_VERSION_CODE_FLAG);
2073     }
2074 }
2075 
2076 //**************************************************************************
2077 //  [Function Name]:
2078 //                  _mdrv_mhl_CbusSendLinkStatusNormal()
2079 //  [Description]:
2080 //
2081 //  [Arguments]:
2082 //
2083 //  [Return]:
2084 //
2085 //**************************************************************************
_mdrv_mhl_CbusSendLinkStatusNormal(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate)2086 void _mdrv_mhl_CbusSendLinkStatusNormal(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate)
2087 {
2088     MS_BOOL bInsertFlag = FALSE;
2089 
2090     if(GET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_LINK_STATUS_NORMAL_FLAG))
2091     {
2092         bInsertFlag = _mdrv_mhl_CbusWriteStatusOrSetInt(pMHLResourcePrivate, 0x91, 0x02, TRUE);
2093 
2094         if(bInsertFlag)
2095         {
2096             SET_MHL_DISPLAY_FLAG(pMHLResourcePrivate->usDisplayIndex, MHL_CBUS_LINK_STATUS_NORMAL_FLAG);
2097         }
2098         else
2099         {
2100             CLR_MHL_DISPLAY_FLAG(pMHLResourcePrivate->usDisplayIndex, MHL_CBUS_LINK_STATUS_NORMAL_FLAG);
2101         }
2102     }
2103 }
2104 
2105 //**************************************************************************
2106 //  [Function Name]:
2107 //                  _mdrv_mhl_GetEnhanceCbusFlag()
2108 //  [Description]
2109 //
2110 //  [Arguments]:
2111 //
2112 //  [Return]:
2113 //
2114 //**************************************************************************
_mdrv_mhl_GetEnhanceCbusFlag(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate)2115 MS_BOOL _mdrv_mhl_GetEnhanceCbusFlag(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate)
2116 {
2117     MS_BOOL bECbusSupport = GET_MHL_CHIP_FLAG(pMHLResourcePrivate->ucChipCapability, MHL_CHIP_ECBUS_ENGINE_SUPPORT_FLAG);
2118 
2119     if(pMHLResourcePrivate->ucDeviceCapabilityTable[MHL_CBUS_VERSION] < 0x30)
2120     {
2121         bECbusSupport = FALSE;
2122     }
2123 
2124     return bECbusSupport;
2125 }
2126 
2127 //**************************************************************************
2128 //  [Function Name]:
2129 //                  _mdrv_mhl_CbusTimerEventProc()
2130 //  [Description]:
2131 //
2132 //  [Arguments]:
2133 //
2134 //  [Return]:
2135 //
2136 //**************************************************************************
_mdrv_mhl_CbusTimerEventProc(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate)2137 void _mdrv_mhl_CbusTimerEventProc(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate)
2138 {
2139     if(GET_MHL_TIMER_FLAG(pMHLResourcePrivate->ulTimerIndex, MHL_TIMER_CBUS_SILENCE_FLAG))
2140     {
2141         CLR_MHL_TIMER_FLAG(pMHLResourcePrivate->ulTimerIndex, MHL_TIMER_CBUS_SILENCE_FLAG);
2142         SET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_CBUS_SEND_FLAG);
2143 
2144 #if(MHL_DEBUG_TIMER_EVENT)
2145         MDRV_MHL_MSG_INFO("** MHL timer event %d timeout\r\n", MHL_TIMER_EVENT_CBUS_SILENCE);
2146 #endif
2147     }
2148 
2149     if(GET_MHL_TIMER_FLAG(pMHLResourcePrivate->ulTimerIndex, MHL_TIMER_DISPLAY_COMMAND_FLAG))
2150     {
2151         CLR_MHL_TIMER_FLAG(pMHLResourcePrivate->ulTimerIndex, MHL_TIMER_DISPLAY_COMMAND_FLAG);
2152         SET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_DISPLAY_COMMAND_ENABLE_FLAG);
2153 
2154 #if(MHL_DEBUG_TIMER_EVENT)
2155         MDRV_MHL_MSG_INFO("** MHL timer event %d timeout\r\n", MHL_TIMER_EVENT_DISPLAY_COMMAND);
2156 #endif
2157     }
2158 
2159     if(GET_MHL_TIMER_FLAG(pMHLResourcePrivate->ulTimerIndex, MHL_TIMER_WAIT_MSG_RESPONSE_FLAG))
2160     {
2161         CLR_MHL_TIMER_FLAG(pMHLResourcePrivate->ulTimerIndex, MHL_TIMER_WAIT_MSG_RESPONSE_FLAG);
2162         CLR_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_MSG_COMMAND_FLAG);
2163 
2164 #if(MHL_DEBUG_TIMER_EVENT)
2165         MDRV_MHL_MSG_INFO("** MHL timer event %d timeout\r\n", MHL_TIMER_EVENT_WAIT_MSG_RESPONSE);
2166 #endif
2167     }
2168 
2169     if(GET_MHL_TIMER_FLAG(pMHLResourcePrivate->ulTimerIndex, MHL_TIMER_RCP_AUTO_RELEASE_FLAG))
2170     {
2171         if(_mdrv_mhl_CbusSendSubMessage(pMHLResourcePrivate, MSC_MSG_RCP, (pMHLResourcePrivate->ucPreRCPKeyCode |BIT(7)), TRUE))
2172         {
2173             CLR_MHL_TIMER_FLAG(pMHLResourcePrivate->ulTimerIndex, MHL_TIMER_RCP_AUTO_RELEASE_FLAG);
2174             CLR_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_RCP_RELEASE_ENABLE_FLAG);
2175 
2176 #if(MHL_DEBUG_TIMER_EVENT)
2177             MDRV_MHL_MSG_INFO("** MHL timer event %d timeout\r\n", MHL_TIMER_EVENT_RCP_AUTO_RELEASE);
2178 #endif
2179         }
2180     }
2181 
2182     if(GET_MHL_TIMER_FLAG(pMHLResourcePrivate->ulTimerIndex, MHL_TIMER_WAIT_WRITE_GRANT_FLAG))
2183     {
2184         CLR_MHL_TIMER_FLAG(pMHLResourcePrivate->ulTimerIndex, MHL_TIMER_WAIT_WRITE_GRANT_FLAG);
2185 
2186         if(pMHLResourcePrivate->ucWriteBurstState == MHL_CBUS_WRITE_BURST_SEND_REQUEST)
2187         {
2188             pMHLResourcePrivate->ucWriteBurstState = MHL_CBUS_WRITE_BURST_START;
2189         }
2190 
2191 #if(MHL_DEBUG_TIMER_EVENT)
2192         MDRV_MHL_MSG_INFO("** MHL timer event %d timeout\r\n", MHL_TIMER_EVENT_WAIT_WRITE_GRANT);
2193 #endif
2194     }
2195 
2196     if(GET_MHL_TIMER_FLAG(pMHLResourcePrivate->ulTimerIndex, MHL_TIMER_CHECK_RECEIVE_LOSE_FLAG))
2197     {
2198         CLR_MHL_TIMER_FLAG(pMHLResourcePrivate->ulTimerIndex, MHL_TIMER_CHECK_RECEIVE_LOSE_FLAG);
2199 
2200         if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_RECEIVE_LOSE_FLAG))
2201         {
2202             CLR_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_RECEIVE_LOSE_FLAG);
2203 
2204             if(pMHLResourcePrivate->ucReceiveCounter == 0)
2205             {
2206                 pMHLResourcePrivate->ucReceiveCounter++;
2207             }
2208         }
2209 
2210 #if(MHL_DEBUG_TIMER_EVENT)
2211         MDRV_MHL_MSG_INFO("** MHL timer event %d timeout\r\n", MHL_TIMER_EVENT_CHECK_RECEIVE_LOSE);
2212 #endif
2213     }
2214 
2215     if(GET_MHL_TIMER_FLAG(pMHLResourcePrivate->ulTimerIndex, MHL_TIMER_SEND_MSG_RESPONSE_FLAG))
2216     {
2217         if(_mdrv_mhl_CbusSendSubMessage(pMHLResourcePrivate, pMHLResourcePrivate->ucMSGData[0], pMHLResourcePrivate->ucMSGData[1], FALSE))
2218         {
2219             CLR_MHL_TIMER_FLAG(pMHLResourcePrivate->ulTimerIndex, MHL_TIMER_SEND_MSG_RESPONSE_FLAG);
2220 
2221 #if(MHL_DEBUG_TIMER_EVENT)
2222             MDRV_MHL_MSG_INFO("** MHL timer event %d timeout\r\n", MHL_TIMER_EVENT_SEND_MSG_RESPONSE);
2223 #endif
2224         }
2225     }
2226 
2227     if(GET_MHL_TIMER_FLAG(pMHLResourcePrivate->ulTimerIndex, MHL_TIMER_CHECK_CONTENT_ON_FLAG))
2228     {
2229         CLR_MHL_TIMER_FLAG(pMHLResourcePrivate->ulTimerIndex, MHL_TIMER_CHECK_CONTENT_ON_FLAG);
2230         CLR_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_CHECK_CONTENT_ON_FLAG);
2231 
2232 #if(MHL_DEBUG_TIMER_EVENT)
2233         MDRV_MHL_MSG_INFO("** MHL timer event %d timeout\r\n", MHL_TIMER_EVENT_CHECK_CONTENT_ON);
2234 #endif
2235     }
2236 
2237     if(GET_MHL_TIMER_FLAG(pMHLResourcePrivate->ulTimerIndex, MHL_TIMER_AUTO_SWITCH_STOP_FLAG))
2238     {
2239         CLR_MHL_TIMER_FLAG(pMHLResourcePrivate->ulTimerIndex, MHL_TIMER_AUTO_SWITCH_STOP_FLAG);
2240         CLR_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_AUTO_SWITCH_STOP_FLAG);
2241 
2242 #if(MHL_DEBUG_TIMER_EVENT)
2243         MDRV_MHL_MSG_INFO("** MHL timer event %d timeout\r\n", MHL_TIMER_EVENT_AUTO_SWITCH_STOP);
2244 #endif
2245     }
2246 
2247     if(GET_MHL_TIMER_FLAG(pMHLResourcePrivate->ulTimerIndex, MHL_TIMER_WAIT_ECBUS_LOCK_FLAG))
2248     {
2249         CLR_MHL_TIMER_FLAG(pMHLResourcePrivate->ulTimerIndex, MHL_TIMER_WAIT_ECBUS_LOCK_FLAG);
2250 
2251         if(pMHLResourcePrivate->ucECbusState != MHL_ECBUS_STATE_STABLE_POLLING)
2252         {
2253             if(!(pMHLResourcePrivate->ucBISTModeState == MHL_CBUS_BIST_ECBUS_SWITCH)) // Not BIST mode
2254             {
2255                 pMHLResourcePrivate->ucECbusState = MHL_ECBUS_STATE_UNLOCK_RESET;
2256             }
2257         }
2258 
2259 #if(MHL_DEBUG_TIMER_EVENT)
2260         MDRV_MHL_MSG_INFO("** MHL timer event %d timeout\r\n", MHL_TIMER_EVENT_WAIT_ECBUS_LOCK);
2261 #endif
2262     }
2263 
2264     if(GET_MHL_TIMER_FLAG(pMHLResourcePrivate->ulTimerIndex, MHL_TIMER_AUTO_EQ_PROCESS_FLAG))
2265     {
2266         CLR_MHL_TIMER_FLAG(pMHLResourcePrivate->ulTimerIndex, MHL_TIMER_AUTO_EQ_PROCESS_FLAG);
2267         SET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_AUTO_EQ_FUNCTION_FLAG);
2268 
2269 #if(MHL_DEBUG_TIMER_EVENT)
2270         MDRV_MHL_MSG_INFO("** MHL timer event %d timeout\r\n", MHL_TIMER_EVENT_AUTO_EQ_PROCESS);
2271 #endif
2272     }
2273 
2274     if(GET_MHL_TIMER_FLAG(pMHLResourcePrivate->ulTimerIndex, MHL_TIMER_BIST_PROCESS_FLAG))
2275     {
2276         CLR_MHL_TIMER_FLAG(pMHLResourcePrivate->ulTimerIndex, MHL_TIMER_BIST_PROCESS_FLAG);
2277 
2278         if(pMHLResourcePrivate->ucBISTModeState == MHL_CBUS_BIST_ECBUS_SWITCH)
2279         {
2280             pMHLResourcePrivate->ucBISTModeState = MHL_CBUS_BIST_EVENT_FINISH;
2281         }
2282 
2283 #if(MHL_DEBUG_TIMER_EVENT)
2284         MDRV_MHL_MSG_INFO("** MHL timer event %d timeout\r\n", MHL_TIMER_EVENT_BIST_PROCESS);
2285 #endif
2286     }
2287 
2288     if(GET_MHL_TIMER_FLAG(pMHLResourcePrivate->ulTimerIndex, MHL_TIMER_TX_QUEUE_FREEZE_FLAG))
2289     {
2290         CLR_MHL_TIMER_FLAG(pMHLResourcePrivate->ulTimerIndex, MHL_TIMER_TX_QUEUE_FREEZE_FLAG);
2291         CLR_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_CBUS_TX_QUEUE_FREEZE_FLAG);
2292 
2293 #if(MHL_DEBUG_TIMER_EVENT)
2294         MDRV_MHL_MSG_INFO("** MHL timer event %d timeout\r\n", MHL_TIMER_EVENT_TX_QUQUE_FREEZE);
2295 #endif
2296     }
2297 
2298     if(GET_MHL_TIMER_FLAG(pMHLResourcePrivate->ulTimerIndex, MHL_TIMER_POWER_ON_PATCH_FLAG))
2299     {
2300         CLR_MHL_TIMER_FLAG(pMHLResourcePrivate->ulTimerIndex, MHL_TIMER_POWER_ON_PATCH_FLAG);
2301 
2302         if(pMHLResourcePrivate->ucPowerOnPatchState == MHL_POWER_ON_PATCH_STATE_WAIT_PATCH_ON)
2303         {
2304             pMHLResourcePrivate->ucPowerOnPatchState = MHL_POWER_ON_PATCH_STATE_PATCH_ON;
2305         }
2306         else if(pMHLResourcePrivate->ucPowerOnPatchState == MHL_POWER_ON_PATCH_STATE_WAIT_PATCH_OFF)
2307         {
2308             pMHLResourcePrivate->ucPowerOnPatchState = MHL_POWER_ON_PATCH_STATE_PATCH_OFF;
2309         }
2310 
2311 #if(MHL_DEBUG_TIMER_EVENT)
2312         MDRV_MHL_MSG_INFO("** MHL timer event %d timeout\r\n", MHL_TIMER_EVENT_POWER_ON_PATCH);
2313 #endif
2314     }
2315 }
2316 
2317 //**************************************************************************
2318 //  [Function Name]:
2319 //                  _mdrv_mhl_TimerHandler()
2320 //  [Description]
2321 //
2322 //  [Arguments]:
2323 //
2324 //  [Return]:
2325 //
2326 //**************************************************************************
_mdrv_mhl_TimerHandler(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate)2327 void _mdrv_mhl_TimerHandler(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate)
2328 {
2329     MS_U8 ucTimerEvent = 0;
2330     MS_U32 ulTimerInterval = 0;
2331     MS_U32 ulTimerTick = (MsOS_GetSystemTime()) %CBUS_TIMER_CONTROL_MASK;
2332 
2333     if(ulTimerTick != pMHLResourcePrivate->ulCurrentTimerTick)
2334     {
2335         ulTimerInterval = (ulTimerTick +CBUS_TIMER_CONTROL_MASK -pMHLResourcePrivate->ulCurrentTimerTick) %CBUS_TIMER_CONTROL_MASK;
2336 
2337         if(ulTimerInterval < 50)
2338         {
2339             for(ucTimerEvent = 0; ucTimerEvent < MHL_TIMER_EVENT_MASK; ucTimerEvent++)
2340             {
2341                 if(pMHLResourcePrivate->stTimerEventInfo[ucTimerEvent].bEnableFlag)
2342                 {
2343                     if(pMHLResourcePrivate->stTimerEventInfo[ucTimerEvent].usTimerTick > ulTimerInterval)
2344                     {
2345                         pMHLResourcePrivate->stTimerEventInfo[ucTimerEvent].usTimerTick = pMHLResourcePrivate->stTimerEventInfo[ucTimerEvent].usTimerTick -ulTimerInterval;
2346                     }
2347                     else
2348                     {
2349                         pMHLResourcePrivate->stTimerEventInfo[ucTimerEvent].usTimerTick = 0;
2350 
2351                         SET_MHL_TIMER_FLAG(pMHLResourcePrivate->ulTimerIndex, BIT(ucTimerEvent));
2352 
2353                         pMHLResourcePrivate->stTimerEventInfo[ucTimerEvent].bEnableFlag = FALSE;
2354                     }
2355                 }
2356             }
2357         }
2358 
2359         pMHLResourcePrivate->ulCurrentTimerTick = ulTimerTick;
2360     }
2361 
2362     if(pMHLResourcePrivate->ulTimerIndex > 0)
2363     {
2364         _mdrv_mhl_CbusTimerEventProc(pMHLResourcePrivate);
2365     }
2366 }
2367 
2368 //**************************************************************************
2369 //  [Function Name]:
2370 //                  _mdrv_mhl_ECbusStateHandler()
2371 //  [Description]
2372 //
2373 //  [Arguments]:
2374 //
2375 //  [Return]:
2376 //
2377 //**************************************************************************
_mdrv_mhl_ECbusStateHandler(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate)2378 void _mdrv_mhl_ECbusStateHandler(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate)
2379 {
2380     MS_U8 ucECbusEvent = MHL_ECBUS_EVENT_NONE;
2381     MS_U8 ucECbusStatusFlag = mhal_mhl_GetECbusStatusFlag();
2382 
2383     if((pMHLResourcePrivate->stSignalStatusInfo.ucECbusTrainState < MHL_ECBUS_STATE_FAIL) && (pMHLResourcePrivate->stSignalStatusInfo.ucECbusTrainState >= MHL_ECBUS_STATE_SOURCE_ACTIVE))
2384     {
2385         ucECbusStatusFlag |= MHL_ECBUS_STATUS_TRAINING_PASS;
2386     }
2387 
2388     switch(pMHLResourcePrivate->ucECbusState)
2389     {
2390         case MHL_ECBUS_STATE_RECEIVE_MODE_UP:
2391             if(_mdrv_mhl_CbusSendSubMessage(pMHLResourcePrivate, MSC_MSG_RAPK, 0x00, FALSE))
2392             {
2393                 // Freeze Tx queue, not allow any Cbus command insert Tx queue
2394                 SET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_CBUS_TX_QUEUE_FREEZE_FLAG);
2395 
2396                 pMHLResourcePrivate->ucECbusState = MHL_ECBUS_STATE_TRIGGER_MODE_UP;
2397 
2398                 ucECbusEvent = MHL_ECBUS_EVENT_PREPARE_MODE_UP;
2399 
2400                 MDRV_MHL_MSG_INFO("** MHL receive mode up !! port %c\r\n", MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath));
2401             }
2402 
2403             break;
2404 
2405         case MHL_ECBUS_STATE_BIST_MODE_UP:
2406             // Freeze Tx queue, not allow any Cbus command insert Tx queue
2407             SET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_CBUS_TX_QUEUE_FREEZE_FLAG);
2408 
2409             pMHLResourcePrivate->ucECbusState = MHL_ECBUS_STATE_TRIGGER_MODE_UP;
2410 
2411             ucECbusEvent = MHL_ECBUS_EVENT_PREPARE_MODE_UP;
2412 
2413             MDRV_MHL_MSG_INFO("** MHL BIST trigger mode up !! port %c\r\n", MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath));
2414 
2415             break;
2416 
2417         case MHL_ECBUS_STATE_TRIGGER_MODE_UP:
2418             // Wait Tx queue empty, then trigger eCbus mode up
2419             if(_mdrv_mhl_GetCbusQueueIndex(pMHLResourcePrivate) == MHL_CBUS_TOTAL_QUEUE_NUM)
2420             {
2421                 pMHLResourcePrivate->ucECbusState = MHL_ECBUS_STATE_PROCESS_MODE_UP;
2422                 pMHLResourcePrivate->stSignalStatusInfo.bECbusEnableFlag = TRUE;
2423 
2424                 ucECbusEvent = MHL_ECBUS_EVENT_MODE_UP_PROCESS;
2425 
2426                 _mdrv_mhl_SetCbusTimerEvent(pMHLResourcePrivate, MHL_TIMER_EVENT_WAIT_ECBUS_LOCK, MHL_WAIT_ECBUS_LOCK_TIME);
2427 
2428                 MDRV_MHL_MSG_INFO("** MHL Tx queue empty trigger mode up !! port %c\r\n", MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath));
2429             }
2430 
2431             break;
2432 
2433         case MHL_ECBUS_STATE_PROCESS_MODE_UP:
2434             if(ucECbusStatusFlag &MHL_ECBUS_STATUS_SLOT_SYNC_DONE)
2435             {
2436                 CLR_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_CBUS_TX_QUEUE_FREEZE_FLAG);
2437                 SET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_AUTO_EQ_FUNCTION_FLAG);
2438                 SET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_CBUS1_FUNCTION_FLAG);
2439 
2440                 pMHLResourcePrivate->ucECbusState = MHL_ECBUS_STATE_MODE_UP_CLOCK_LOCK;
2441 
2442                 MDRV_MHL_MSG_INFO("** MHL Cbus1 command enable !! port %c\r\n", MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath));
2443             }
2444 
2445             break;
2446 
2447         case MHL_ECBUS_STATE_MODE_UP_CLOCK_LOCK:
2448             if(ucECbusStatusFlag &MHL_ECBUS_STATUS_EMSC_SYNC_DONE)
2449             {
2450                 SET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_EMSC_FUNCTION_FLAG);
2451 
2452                 pMHLResourcePrivate->ucECbusState = MHL_ECBUS_STATE_STABLE_POLLING;
2453 
2454                 MDRV_MHL_MSG_INFO("** MHL eMSC command enable !! port %c\r\n", MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath));
2455 
2456                 if(GET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_COMMUNICATE_BUSY_FLAG))
2457                 {
2458                     CLR_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_COMMUNICATE_BUSY_FLAG);
2459                 }
2460             }
2461 
2462             break;
2463 
2464         case MHL_ECBUS_STATE_STABLE_POLLING:
2465             if((ucECbusStatusFlag &(MHL_ECBUS_STATUS_TRAINING_PASS)) == 0)
2466             {
2467                 pMHLResourcePrivate->ucECbusState = MHL_ECBUS_STATE_NONE;
2468 
2469                 ucECbusEvent = MHL_ECBUS_EVENT_STUCK_TO_LOW;
2470 
2471                 MDRV_MHL_MSG_INFO("** MHL eCbus lose lock to reset !! port %c\r\n", MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath));
2472             }
2473             else if(ucECbusStatusFlag &MHL_ECBUS_STATUS_RETRY_TIMEOUT)
2474             {
2475                 pMHLResourcePrivate->ucECbusState = MHL_ECBUS_STATE_NONE;
2476 
2477                 ucECbusEvent = MHL_ECBUS_EVENT_STUCK_TO_LOW;
2478             }
2479             else
2480             {
2481                 ucECbusEvent = MHL_ECBUS_EVENT_ECBUS_COMMAND_PARSING;
2482             }
2483 
2484             break;
2485 
2486         case MHL_ECBUS_STATE_UNLOCK_RESET:
2487             pMHLResourcePrivate->ucECbusState = MHL_ECBUS_STATE_NONE;
2488 
2489             ucECbusEvent = MHL_ECBUS_EVENT_STUCK_TO_LOW;
2490 
2491             MDRV_MHL_MSG_INFO("** MHL eCbus training timeout to reset !! port %c\r\n", MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath));
2492 
2493             break;
2494 
2495         case MHL_ECBUS_STATE_RECEIVE_MODE_DOWN:
2496             if(_mdrv_mhl_CbusSendSubMessage(pMHLResourcePrivate, MSC_MSG_RAPK, 0x00, FALSE))
2497             {
2498                 // Freeze Tx queue, not allow any Cbus command insert Tx queue
2499                 SET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_CBUS_TX_QUEUE_FREEZE_FLAG);
2500 
2501                 pMHLResourcePrivate->ucECbusState = MHL_ECBUS_STATE_TRIGGER_MODE_DOWN;
2502 
2503                 MDRV_MHL_MSG_INFO("** MHL receive mode down !! port %c\r\n", MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath));
2504             }
2505 
2506             break;
2507 
2508         case MHL_ECBUS_STATE_BIST_MODE_DOWN:
2509             // Freeze Tx queue, not allow any Cbus command insert Tx queue
2510             SET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_CBUS_TX_QUEUE_FREEZE_FLAG);
2511 
2512             pMHLResourcePrivate->ucECbusState = MHL_ECBUS_STATE_TRIGGER_MODE_DOWN;
2513 
2514             MDRV_MHL_MSG_INFO("** MHL BIST trigger mode down !! port %c\r\n", MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath));
2515 
2516             break;
2517 
2518         case MHL_ECBUS_STATE_TRIGGER_MODE_DOWN:
2519             // Wait Tx queue empty, then trigger eCbus mode up
2520             if(_mdrv_mhl_GetCbusQueueIndex(pMHLResourcePrivate) == MHL_CBUS_TOTAL_QUEUE_NUM)
2521             {
2522                 pMHLResourcePrivate->ucECbusState = MHL_ECBUS_STATE_PROCESS_MODE_DOWN;
2523                 pMHLResourcePrivate->stSignalStatusInfo.bECbusEnableFlag = FALSE;
2524 
2525                 ucECbusEvent = MHL_ECBUS_EVENT_MODE_DOWN_PROCESS;
2526 
2527                 MDRV_MHL_MSG_INFO("** MHL Tx queue empty trigger mode down !! port %c\r\n", MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath));
2528             }
2529 
2530             break;
2531 
2532         default:
2533 
2534             break;
2535     };
2536 
2537     if(pMHLResourcePrivate->ucECbusTrainState != pMHLResourcePrivate->stSignalStatusInfo.ucECbusTrainState)
2538     {
2539         pMHLResourcePrivate->ucECbusTrainState = pMHLResourcePrivate->stSignalStatusInfo.ucECbusTrainState;
2540 
2541         MDRV_MHL_MSG_INFO("** MHL eCbus state %x\r\n", pMHLResourcePrivate->ucECbusTrainState);
2542     }
2543 
2544     mhal_mhl_ECbusEventProc(pMHLResourcePrivate->ucMHLSupportPath, ucECbusEvent, pMHLResourcePrivate->stSignalStatusInfo.bBISTEnableFlag, &(pMHLResourcePrivate->stBISTParameterInfo));
2545 }
2546 
2547 //**************************************************************************
2548 //  [Function Name]:
2549 //                  _mdrv_mhl_DisplayCommandCheckFlag()
2550 //  [Description]
2551 //
2552 //  [Arguments]:
2553 //
2554 //  [Return]:
2555 //
2556 //**************************************************************************
_mdrv_mhl_DisplayCommandCheckFlag(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate)2557 MS_BOOL _mdrv_mhl_DisplayCommandCheckFlag(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate)
2558 {
2559     MS_BOOL bCheckFlag = TRUE;
2560     MS_U16 usDisplayCheck = (pMHLResourcePrivate->usDisplayIndex) >> MHL_CBUS_DISPLAY_MASK_SHIFT;
2561 
2562     if(((usDisplayCheck &MHL_CBUS_DISPLAY_MASK) ^MHL_CBUS_DISPLAY_MASK) > 0)
2563     {
2564         bCheckFlag = FALSE;
2565     }
2566 
2567     return bCheckFlag;
2568 }
2569 
2570 //**************************************************************************
2571 //  [Function Name]:
2572 //                  _mdrv_mhl_PowerOnPatchProc()
2573 //  [Description]
2574 //
2575 //  [Arguments]:
2576 //
2577 //  [Return]:
2578 //
2579 //**************************************************************************
_mdrv_mhl_PowerOnPatchProc(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate)2580 void _mdrv_mhl_PowerOnPatchProc(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate)
2581 {
2582     switch(pMHLResourcePrivate->ucPowerOnPatchState)
2583     {
2584         case MHL_POWER_ON_PATCH_STATE_START:
2585             _mdrv_mhl_SetCbusTimerEvent(pMHLResourcePrivate, MHL_TIMER_EVENT_POWER_ON_PATCH, MHL_WAIT_PATCH_ON_TIME);
2586 
2587             pMHLResourcePrivate->ucPowerOnPatchState = MHL_POWER_ON_PATCH_STATE_WAIT_PATCH_ON;
2588 
2589             break;
2590 
2591         case MHL_POWER_ON_PATCH_STATE_PATCH_ON:
2592             _mdrv_mhl_SetCbusTimerEvent(pMHLResourcePrivate, MHL_TIMER_EVENT_POWER_ON_PATCH, MHL_WAIT_PATCH_OFF_TIME);
2593 
2594             pMHLResourcePrivate->ucPowerOnPatchState = MHL_POWER_ON_PATCH_STATE_WAIT_PATCH_OFF;
2595 
2596             mhal_mhl_ECbusEventProc(pMHLResourcePrivate->ucMHLSupportPath, MHL_ECBUS_EVENT_POWER_ON_PATCH_ON, pMHLResourcePrivate->stSignalStatusInfo.bBISTEnableFlag, &(pMHLResourcePrivate->stBISTParameterInfo));
2597 
2598             MDRV_MHL_MSG_INFO("** MHL power on patch on !! port %c\r\n", MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath));
2599 
2600             break;
2601 
2602         case MHL_POWER_ON_PATCH_STATE_PATCH_OFF:
2603             pMHLResourcePrivate->ucPowerOnPatchState = MHL_POWER_ON_PATCH_STATE_DONE;
2604 
2605             mhal_mhl_ECbusEventProc(pMHLResourcePrivate->ucMHLSupportPath, MHL_ECBUS_EVENT_POWER_ON_PATCH_OFF, pMHLResourcePrivate->stSignalStatusInfo.bBISTEnableFlag, &(pMHLResourcePrivate->stBISTParameterInfo));
2606 
2607             MDRV_MHL_MSG_INFO("** MHL power on patch off !! port %c\r\n", MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath));
2608 
2609             break;
2610 
2611         case MHL_POWER_ON_PATCH_STATE_DONE:
2612             pMHLResourcePrivate->ucPowerOnPatchState = MHL_POWER_ON_PATCH_STATE_NONE;
2613             break;
2614 
2615         default:
2616 
2617             break;
2618     };
2619 }
2620 
2621 //**************************************************************************
2622 //  [Function Name]:
2623 //                  _mdrv_mhl_CheckStatusPolling()
2624 //  [Description]
2625 //
2626 //  [Arguments]:
2627 //
2628 //  [Return]:
2629 //
2630 //**************************************************************************
_mdrv_mhl_CheckStatusPolling(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate)2631 void _mdrv_mhl_CheckStatusPolling(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate)
2632 {
2633     MS_BOOL bSourceChangeFlag = FALSE;
2634     MS_U8 ucCurrentHDMIPort = mhal_mhl_GetInputPort();
2635 
2636     // For cable detect
2637     if(mhal_mhl_CableDetect(pMHLResourcePrivate->ucMHLSupportPath)) // Cable plugged
2638     {
2639         if(!GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CABLE_PLUG_FLAG))
2640         {
2641             mhal_mhl_CablePlugProc(pMHLResourcePrivate->ucMHLSupportPath, &(pMHLResourcePrivate->stSignalStatusInfo));
2642 
2643             MDRV_MHL_MSG_INFO("** MHL Cable plugged!! port %c\r\n", MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath));
2644 
2645             SET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CABLE_PLUG_FLAG);
2646         }
2647 
2648         if(!GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_SOURCE_CHANGE_FLAG))
2649         {
2650             SET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_SOURCE_CHANGE_FLAG);
2651         }
2652 
2653         // For Cbus
2654         if(mhal_mhl_CbusStatus() == 0x03) // Cbus connect
2655         {
2656             if(!GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CBUS_CONNECT_FLAG))
2657             {
2658                 mhal_mhl_CbusConnectProc(pMHLResourcePrivate->ucMHLSupportPath);
2659 
2660                 pMHLResourcePrivate->ucTMDSClockMode = MHL_PHY_CLOCK_NORMAL_24BIT;
2661 
2662                 _mdrv_mhl_SetCbusTimerEvent(pMHLResourcePrivate, MHL_TIMER_EVENT_DISPLAY_COMMAND, MHL_CBUS_CONNECT_HOLD_TIME);
2663 
2664                 CLR_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_DISPLAY_COMMAND_ENABLE_FLAG);
2665 
2666                 _mdrv_mhl_SetCbusTimerEvent(pMHLResourcePrivate, MHL_TIMER_EVENT_CBUS_SILENCE, MHL_CBUS_CONNECT_SILENCE_TIME);
2667 
2668                 CLR_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_CBUS_SEND_FLAG);
2669 
2670                 if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CHECK_CONTENT_ENABLE_FLAG))
2671                 {
2672                     _mdrv_mhl_SetCbusTimerEvent(pMHLResourcePrivate, MHL_TIMER_EVENT_CHECK_CONTENT_ON, MHL_CHECK_CONTENT_ON_TIME);
2673 
2674                     SET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_CHECK_CONTENT_ON_FLAG);
2675                     SET_MHL_DISPLAY_FLAG(pMHLResourcePrivate->usDisplayIndex, MHL_CBUS_PATH_EN_FLAG);
2676                 }
2677 
2678                 MDRV_MHL_MSG_INFO("** MHL Cbus connected~~ ^Q^ port %c\r\n", MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath));
2679 
2680                 SET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CBUS_CONNECT_FLAG);
2681             }
2682 
2683             if(GET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_ECBUS_FUNCTION_FLAG))
2684             {
2685                 _mdrv_mhl_ECbusStateHandler(pMHLResourcePrivate);
2686 
2687 #if(MHL3_AUTO_EQ_ENABLE)
2688                 if(GET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_AUTO_EQ_FUNCTION_FLAG))
2689                 {
2690                     CLR_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_AUTO_EQ_FUNCTION_FLAG);
2691 
2692                     mhal_mhl_AutoEQEventProc(pMHLResourcePrivate->ucMHLSupportPath, &(pMHLResourcePrivate->stSignalStatusInfo));
2693 
2694                     _mdrv_mhl_SetCbusTimerEvent(pMHLResourcePrivate, MHL_TIMER_EVENT_AUTO_EQ_PROCESS, MHL_AUTO_EQ_PROCESS_TIME);
2695                 }
2696 #endif
2697             }
2698             else if(GET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_COMMUNICATE_BUSY_FLAG))
2699             {
2700                 CLR_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_COMMUNICATE_BUSY_FLAG);
2701             }
2702 
2703             mhal_mhl_CDRModeMonitor(pMHLResourcePrivate->ucMHLSupportPath, _mdrv_mhl_DisplayCommandCheckFlag(pMHLResourcePrivate), &(pMHLResourcePrivate->stSignalStatusInfo));
2704         }
2705         else // Cbus disconnection
2706         {
2707             if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CBUS_CONNECT_FLAG))
2708             {
2709                 mhal_mhl_CbusStucktoLowProc(pMHLResourcePrivate->ucMHLSupportPath);
2710 
2711                 mhal_mhl_CDRModeMonitor(pMHLResourcePrivate->ucMHLSupportPath, FALSE, &(pMHLResourcePrivate->stSignalStatusInfo));
2712 
2713                 _mdrv_mhl_ClearCbusFlag(pMHLResourcePrivate, MHL_CLEAR_CONNECT_LOSS_FLAG);
2714 
2715                 if(pMHLResourcePrivate->ucTMDSClockMode == MHL_PHY_CLOCK_PACKET_PIXEL)
2716                 {
2717                     mhal_mhl_ClockModeSwitchProc(pMHLResourcePrivate->ucMHLSupportPath, FALSE, &(pMHLResourcePrivate->stSignalStatusInfo));
2718 
2719                     pMHLResourcePrivate->ucTMDSClockMode = MHL_PHY_CLOCK_NORMAL_24BIT;
2720                 }
2721 
2722                 MDRV_MHL_MSG_INFO("** MHL Cbus stuck to low @@ port %c\r\n", MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath));
2723 
2724                 CLR_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CBUS_CONNECT_FLAG);
2725             }
2726         }
2727     }
2728     else // Cable unplugged
2729     {
2730         if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CABLE_PLUG_FLAG))
2731         {
2732             mhal_mhl_CableRemoveProc(pMHLResourcePrivate->ucMHLSupportPath, &(pMHLResourcePrivate->stSignalStatusInfo));
2733 
2734             mhal_mhl_ECbusEventProc(pMHLResourcePrivate->ucMHLSupportPath, MHL_ECBUS_EVENT_STUCK_TO_LOW, pMHLResourcePrivate->stSignalStatusInfo.bBISTEnableFlag, &(pMHLResourcePrivate->stBISTParameterInfo));
2735 
2736             _mdrv_mhl_ClearCbusFlag(pMHLResourcePrivate, MHL_CLEAR_CABLE_LOSS_FLAG);
2737 
2738             MDRV_MHL_MSG_INFO("** MHL Cable remove~~~ port %c\r\n", MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath));
2739 
2740             CLR_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CABLE_PLUG_FLAG);
2741 
2742             if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CBUS_CONNECT_FLAG))
2743             {
2744                 CLR_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CBUS_CONNECT_FLAG);
2745             }
2746         }
2747 
2748         mhal_mhl_Accumulator_Clr(pMHLResourcePrivate->ucMHLSupportPath);
2749     }
2750 
2751     // For source change
2752     if(pMHLResourcePrivate->ucCurrentHDMIPort != ucCurrentHDMIPort)
2753     {
2754         if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_SOURCE_CHANGE_FLAG))
2755         {
2756             if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CABLE_PLUG_FLAG))
2757             {
2758                 bSourceChangeFlag = TRUE;
2759             }
2760             else if(!mhal_mhl_CheckInputPort(pMHLResourcePrivate->ucMHLSupportPath))
2761             {
2762                 bSourceChangeFlag = TRUE;
2763             }
2764 
2765             if(bSourceChangeFlag)
2766             {
2767                 mhal_mhl_SourceChangeProc(pMHLResourcePrivate->ucMHLSupportPath, pMHLResourcePrivate->stSignalStatusInfo.ucMainLinkRate);
2768 
2769                 if(pMHLResourcePrivate->ucTMDSClockMode == MHL_PHY_CLOCK_PACKET_PIXEL)
2770                 {
2771                     mhal_mhl_ClockModeSwitchProc(pMHLResourcePrivate->ucMHLSupportPath, TRUE, &(pMHLResourcePrivate->stSignalStatusInfo));
2772                 }
2773             }
2774 
2775             CLR_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_SOURCE_CHANGE_FLAG);
2776         }
2777 
2778         pMHLResourcePrivate->ucCurrentHDMIPort = ucCurrentHDMIPort;
2779     }
2780 
2781     // Normal Cbus engine
2782     if(!GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CBUS_NORMAL_FLAG))
2783     {
2784         mhal_mhl_CbusIsolate(pMHLResourcePrivate->ucMHLSupportPath, FALSE);
2785         mhal_mhl_VbusCharge(pMHLResourcePrivate->ucMHLSupportPath, VBUS_HW_DETECT);
2786         mhal_mhl_CbusFloating(FALSE);
2787 
2788         _mdrv_mhl_ClearCbusFlag(pMHLResourcePrivate, MHL_CLEAR_CABLE_LOSS_FLAG);
2789 
2790         SET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CBUS_NORMAL_FLAG);
2791 
2792         pMHLResourcePrivate->ucPowerOnPatchState = MHL_POWER_ON_PATCH_STATE_START;
2793     }
2794 
2795     _mdrv_mhl_PowerOnPatchProc(pMHLResourcePrivate);
2796 }
2797 
2798 //**************************************************************************
2799 //  [Function Name]:
2800 //                  _mdrv_mhl_GetCbusReceiveMSC()
2801 //  [Description]:
2802 //
2803 //  [Arguments]:
2804 //
2805 //  [Return]:
2806 //
2807 //**************************************************************************
_mdrv_mhl_GetCbusReceiveMSC(MS_U8 * ucReceiveMSC)2808 MS_BOOL _mdrv_mhl_GetCbusReceiveMSC(MS_U8 *ucReceiveMSC)
2809 {
2810     MS_BOOL bGetMSCFlag = FALSE;
2811     MS_U8 uctemp = 0;
2812     MS_U16 usLength = 0;
2813     MS_U16 usValue = 0;
2814 
2815     usLength = (mhal_mhl_GetSRAMReceiveData()) &BMASK(6:0); // Get MSC command length
2816 
2817     if(usLength > 0)
2818     {
2819         ucReceiveMSC[0] = usLength -1;
2820 
2821 #if(MHL_DEBUG_RECEIVE_MSC)
2822         MDRV_MHL_MSG_DEBUG(" MHL receive MSG length = %x\r\n", (usLength &BMASK(7:0)));
2823 #endif
2824 
2825         usValue = mhal_mhl_GetSRAMReceiveData(); // Get MSC command
2826 
2827         if(usValue &BIT(8))
2828         {
2829             ucReceiveMSC[1] = usValue &BMASK(7:0);
2830 
2831 #if(MHL_DEBUG_RECEIVE_MSC)
2832             MDRV_MHL_MSG_DEBUG(" MHL receive MSG command = %x\r\n", (usValue &BMASK(7:0)));
2833 #endif
2834         }
2835         else
2836         {
2837             ucReceiveMSC[0] = 2;
2838             ucReceiveMSC[1] = MSC_ACK;
2839             ucReceiveMSC[2] = usValue &BMASK(7:0);
2840 
2841 #if(MHL_DEBUG_RECEIVE_MSC)
2842             MDRV_MHL_MSG_DEBUG(" MHL receive MSG data = %x\r\n", (usValue &BMASK(7:0)));
2843 #endif
2844         }
2845 
2846         for(uctemp = 0; uctemp < (usLength -2); uctemp++)
2847         {
2848             usValue = mhal_mhl_GetSRAMReceiveData(); // Get MSC data
2849 
2850             if((usValue &BIT(8)) == BIT(8)) // Command in data error happen
2851             {
2852                 // For CTS 6.3.6.5 entry 4
2853                 if((usValue &BMASK(7:0)) == MSC_ABORT)
2854                 {
2855                     ucReceiveMSC[1] = usValue &BMASK(7:0);
2856                 }
2857                 else if((usValue &BMASK(7:0)) == MSC_EOF)
2858                 {
2859                     // EOF is command but it is not error
2860                     ucReceiveMSC[uctemp +2] = usValue &BMASK(7:0);
2861                 }
2862                 else // Ignort command
2863                 {
2864                     ucReceiveMSC[1] = MSC_NONE;
2865                 }
2866 
2867 #if(MHL_DEBUG_RECEIVE_MSC)
2868                 MDRV_MHL_MSG_DEBUG(" MHL receive MSG command = %x\r\n", (usValue &BMASK(7:0)));
2869 #endif
2870             }
2871             else
2872             {
2873                 ucReceiveMSC[uctemp +2] = usValue &BMASK(7:0);
2874 
2875 #if(MHL_DEBUG_RECEIVE_MSC)
2876                 MDRV_MHL_MSG_DEBUG(" MHL receive MSG data = %x\r\n", (usValue &BMASK(7:0)));
2877 #endif
2878             }
2879         }
2880 
2881         bGetMSCFlag = TRUE;
2882     }
2883 
2884     return bGetMSCFlag;
2885 }
2886 
2887 //**************************************************************************
2888 //  [Function Name]:
2889 //                  _mdrv_mhl_SetReceiveCaseFlag()
2890 //  [Description]:
2891 //
2892 //  [Arguments]:
2893 //
2894 //  [Return]:
2895 //
2896 //**************************************************************************
_mdrv_mhl_SetReceiveCaseFlag(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate,MS_U8 * ucReceiveMSC)2897 void _mdrv_mhl_SetReceiveCaseFlag(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate, MS_U8 *ucReceiveMSC)
2898 {
2899     MS_U8 uctemp = 0;
2900 
2901     switch(ucReceiveMSC[1])
2902     {
2903         case MSC_ACK:
2904             SET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_ACK_FLAG);
2905 
2906             if(ucReceiveMSC[0] == 2) // Command length = 2
2907             {
2908                 if(GET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_ASK_DATA_FLAG))
2909                 {
2910                     CLR_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_ASK_DATA_FLAG);
2911                     SET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_ASK_FINISH_FLAG);
2912 
2913                     pMHLResourcePrivate->ucAskData = ucReceiveMSC[2];
2914                 }
2915             }
2916 
2917             break;
2918 
2919         case MSC_ABORT:
2920             SET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_ABORT_FLAG);
2921             break;
2922 
2923         case MSC_MSC_MSG:
2924             SET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_MSG_FLAG);
2925 
2926             pMHLResourcePrivate->ucMSGData[0] = ucReceiveMSC[2];
2927             pMHLResourcePrivate->ucMSGData[1] = ucReceiveMSC[3];
2928             pMHLResourcePrivate->usMSGKeyInfo = (MS_U16)(ucReceiveMSC[2] << 8)| ucReceiveMSC[3];
2929 
2930             break;
2931 
2932         case MSC_WRITE_STAT_OR_SET_INT:
2933             if(ucReceiveMSC[2] == 0x31) // Switch to PP mode or 24 bit mode
2934             {
2935                 if((ucReceiveMSC[3] & BIT(3)) == BIT(3))
2936                 {
2937                     //SET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_PATH_EN_FLAG);
2938                 }
2939 
2940                 if((ucReceiveMSC[3] & BIT(4)) == BIT(4))
2941                 {
2942                     //SET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_MUTED_FLAG);
2943                 }
2944 
2945                 ucReceiveMSC[3] &= BMASK(2:0);
2946 
2947                 if(ucReceiveMSC[3] == MHL_PHY_CLOCK_PACKET_PIXEL)
2948                 {
2949                     SET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_PP_MODE_FLAG);
2950                     CLR_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_24BIT_MODE_FLAG);
2951                 }
2952                 else if(ucReceiveMSC[3] == MHL_PHY_CLOCK_NORMAL_24BIT)
2953                 {
2954                     SET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_24BIT_MODE_FLAG);
2955                     CLR_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_PP_MODE_FLAG);
2956                 }
2957             }
2958 
2959             if(ucReceiveMSC[2] == 0x30)
2960             {
2961                 if((ucReceiveMSC[3] & BIT(0)) == BIT(0)) // Devcap ready
2962                 {
2963                     SET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_DEVCAP_FLAG);
2964                 }
2965 
2966                 if((ucReceiveMSC[3] & BIT(1)) == BIT(1)) // Extended device capability support
2967                 {
2968                     if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CBUS_ENHANCE_FLAG))
2969                     {
2970                         SET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_XDEVCAP_SUPPORT_FLAG);
2971                     }
2972                 }
2973             }
2974 
2975             if((ucReceiveMSC[2] == 0x32) && (ucReceiveMSC[3] >= 0x30)) // Source support MHL3
2976             {
2977                 SET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_MHL3_VERSION_FLAG);
2978             }
2979 
2980             if(ucReceiveMSC[2] == 0x20)
2981             {
2982                 if((ucReceiveMSC[3] & BIT(0)) == BIT(0)) // Devcap change
2983                 {
2984                     SET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_DEVCAP_FLAG);
2985 
2986                     if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CBUS_ENHANCE_FLAG))
2987                     {
2988                         SET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_XDEVCAP_SUPPORT_FLAG);
2989                     }
2990                 }
2991 
2992                 if((ucReceiveMSC[3] & BIT(1)) == BIT(1)) // Scratchpad register change
2993                 {
2994                     SET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_DSCR_CHANGE_FLAG);
2995                 }
2996 
2997                 if((ucReceiveMSC[3] & BIT(2)) == BIT(2)) // Burst write request
2998                 {
2999                     //SET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_WRITE_REQUEST_FLAG);
3000                 }
3001 
3002                 if((ucReceiveMSC[3] & BIT(3)) == BIT(3)) // Burst write grant
3003                 {
3004                     SET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_WRITE_GRANT_FLAG);
3005                 }
3006 
3007                 if((ucReceiveMSC[3] & BIT(4)) == BIT(4)) // 3D request
3008                 {
3009                     SET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_3D_REQ_FLAG);
3010                 }
3011 
3012                 if((ucReceiveMSC[3] & BIT(5)) == BIT(5)) // Feature request
3013                 {
3014                     SET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_FEATURE_REQUEST_FLAG);
3015                 }
3016 
3017                 if((ucReceiveMSC[3] & BIT(6)) == BIT(6)) // Feature complete
3018                 {
3019                     SET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_FEATURE_COMPLETE_FLAG);
3020                 }
3021             }
3022 
3023             break;
3024 
3025         case MSC_WRITE_XSTAT:
3026             if(ucReceiveMSC[2] == 0x90) // eCbus mode
3027             {
3028                 SET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_ECBUS_MODE_FLAG);
3029             }
3030 
3031             if(ucReceiveMSC[2] == 0x92) // Link rate
3032             {
3033                 SET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_LINK_RATE_FLAG);
3034 
3035                 pMHLResourcePrivate->stSignalStatusInfo.ucMainLinkRate = ucReceiveMSC[3];
3036             }
3037 
3038             break;
3039 
3040         case MSC_WRITE_BURST:
3041             SET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_WRITE_BURST_FLAG);
3042 
3043             pMHLResourcePrivate->ucWriteBurstAddress = ucReceiveMSC[2];
3044             pMHLResourcePrivate->ucWriteBurstLength = MHL_MSC_SCRATCHPAD_SIZE +1;
3045 
3046             for(uctemp = 0; uctemp < (MHL_MSC_SCRATCHPAD_SIZE +1); uctemp++)
3047             {
3048                 if(uctemp < pMHLResourcePrivate->ucWriteBurstLength)
3049                 {
3050                     if((ucReceiveMSC[uctemp +3] == MSC_EOF) && (uctemp >= (ucReceiveMSC[0] -3)))
3051                     {
3052                         pMHLResourcePrivate->ucWriteBurstInformation[uctemp] = 0;
3053                         pMHLResourcePrivate->ucWriteBurstLength = uctemp;
3054                     }
3055                     else
3056                     {
3057                         pMHLResourcePrivate->ucWriteBurstInformation[uctemp] = ucReceiveMSC[uctemp +3];
3058                     }
3059                 }
3060                 else if(uctemp < MHL_MSC_SCRATCHPAD_SIZE)
3061                 {
3062                     pMHLResourcePrivate->ucWriteBurstInformation[uctemp] = 0;
3063                 }
3064             }
3065 
3066             break;
3067 
3068         default:
3069 
3070             break;
3071     };
3072 }
3073 
3074 //**************************************************************************
3075 //  [Function Name]:
3076 //                  _mdrv_mhl_CbusDisplayLinkCheck()
3077 //  [Description]
3078 //
3079 //  [Arguments]:
3080 //
3081 //  [Return]:
3082 //
3083 //**************************************************************************
_mdrv_mhl_CbusDisplayLinkCheck(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate)3084 void _mdrv_mhl_CbusDisplayLinkCheck(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate)
3085 {
3086     MS_U8 ucDisplayIndex = (pMHLResourcePrivate->usDisplayIndex) &BMASK(7:0);
3087     MS_U8 ucDisplayMask = MHL_CBUS_DISPLAY_MASK;
3088     MS_U16 usDisplayCheck = (pMHLResourcePrivate->usDisplayIndex) >> MHL_CBUS_DISPLAY_MASK_SHIFT;
3089 
3090     if(GET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_ECBUS_FUNCTION_FLAG))
3091     {
3092         ucDisplayMask = ucDisplayMask |MHL_ECBUS_DISPLAY_MASK;
3093     }
3094 
3095     if((ucDisplayIndex ^ usDisplayCheck) > 0)
3096     {
3097         usDisplayCheck = usDisplayCheck ^ ucDisplayMask;
3098 
3099         if(usDisplayCheck > 0)
3100         {
3101             pMHLResourcePrivate->usDisplayIndex |= (_mdrv_mhl_CbusGetLeastFlag(usDisplayCheck) << MHL_CBUS_DISPLAY_MASK_SHIFT);
3102 
3103             MDRV_MHL_MSG_INFO("** MHL Cbus Receive ACK for Link\r\n");
3104         }
3105     }
3106 }
3107 
3108 //**************************************************************************
3109 //  [Function Name]:
3110 //                  _mdrv_mhl_ParsingWriteBurstVCAssign()
3111 //  [Description]:
3112 //
3113 //  [Arguments]:
3114 //
3115 //  [Return]:
3116 //
3117 //**************************************************************************
_mdrv_mhl_ParsingWriteBurstVCAssign(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate)3118 MS_BOOL _mdrv_mhl_ParsingWriteBurstVCAssign(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate)
3119 {
3120     MS_BOOL bParsingFinish = FALSE;
3121     MS_U8 uctemp = 0;
3122     MS_U8 ucSequence = pMHLResourcePrivate->ucWriteBurstInformation[4];
3123     MS_U8 ucNumberEntry = pMHLResourcePrivate->ucWriteBurstInformation[5];
3124 
3125     if(ucNumberEntry +(ucSequence -1) *MHL_VC_SEQUENCE_LENGTH == pMHLResourcePrivate->ucWriteBurstInformation[3]) // Number entry + (sequece -1) x length = total entry
3126     {
3127         bParsingFinish = TRUE;
3128     }
3129 
3130     for(uctemp = 0; uctemp <ucNumberEntry; uctemp++)
3131     {
3132         _mdrv_mhl_InsertVCInformation(pMHLResourcePrivate, TRUE, pMHLResourcePrivate->ucWriteBurstInformation[uctemp *MHL_VC_SEQUENCE_LENGTH +3], pMHLResourcePrivate->ucWriteBurstInformation[uctemp *MHL_VC_SEQUENCE_LENGTH +4], pMHLResourcePrivate->ucWriteBurstInformation[uctemp *MHL_VC_SEQUENCE_LENGTH +5]);
3133     }
3134 
3135     return bParsingFinish;
3136 }
3137 
3138 //**************************************************************************
3139 //  [Function Name]:
3140 //                  _mdrv_mhl_ParsingWriteBurstVCConfirm()
3141 //  [Description]:
3142 //
3143 //  [Arguments]:
3144 //
3145 //  [Return]:
3146 //
3147 //**************************************************************************
_mdrv_mhl_ParsingWriteBurstVCConfirm(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate)3148 void _mdrv_mhl_ParsingWriteBurstVCConfirm(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate)
3149 {
3150     MS_BOOL bParsingFinish = FALSE;
3151     MS_U8 uctemp = 0;
3152     MS_U8 ucSequence = pMHLResourcePrivate->ucWriteBurstInformation[4];
3153     MS_U8 ucNumberEntry = pMHLResourcePrivate->ucWriteBurstInformation[5];
3154 
3155     if(ucNumberEntry +(ucSequence -1) *MHL_VC_SEQUENCE_LENGTH == pMHLResourcePrivate->ucWriteBurstInformation[3]) // Number entry + (sequece -1) x length = total entry
3156     {
3157         bParsingFinish = TRUE;
3158     }
3159 
3160     for(uctemp = 0; uctemp <ucNumberEntry; uctemp++)
3161     {
3162         _mdrv_mhl_CheckVCInformation(pMHLResourcePrivate, pMHLResourcePrivate->ucWriteBurstInformation[uctemp *MHL_VC_SEQUENCE_LENGTH +3], pMHLResourcePrivate->ucWriteBurstInformation[uctemp *MHL_VC_SEQUENCE_LENGTH +4], pMHLResourcePrivate->ucWriteBurstInformation[uctemp *MHL_VC_SEQUENCE_LENGTH +5]);
3163     }
3164 
3165     if(bParsingFinish)
3166     {
3167         _mdrv_mhl_SortingVCInformation(pMHLResourcePrivate, TRUE);
3168 
3169         _mdrv_mhl_eCbusTimeSlotAllocation(pMHLResourcePrivate);
3170     }
3171 }
3172 
3173 //**************************************************************************
3174 //  [Function Name]:
3175 //                  _mdrv_mhl_CheckAVLineVideoMode()
3176 //  [Description]:
3177 //
3178 //  [Arguments]:
3179 //
3180 //  [Return]:
3181 //
3182 //**************************************************************************
_mdrv_mhl_CheckAVLineVideoMode(MS_U8 ucAVLinkVideoMode)3183 MS_U8 _mdrv_mhl_CheckAVLineVideoMode(MS_U8 ucAVLinkVideoMode)
3184 {
3185     MS_U8 ucFrameRate = 1;
3186 
3187     switch(ucAVLinkVideoMode)
3188     {
3189         case MHL_VIC_INDEX1:
3190         case MHL_VIC_INDEX2:
3191         case MHL_VIC_INDEX3:
3192         case MHL_VIC_INDEX4:
3193         case MHL_VIC_INDEX5:
3194         case MHL_VIC_INDEX6:
3195         case MHL_VIC_INDEX7:
3196         case MHL_VIC_INDEX16:
3197             ucFrameRate = 60;
3198             break;
3199 
3200         case MHL_VIC_INDEX17:
3201         case MHL_VIC_INDEX18:
3202         case MHL_VIC_INDEX19:
3203         case MHL_VIC_INDEX20:
3204         case MHL_VIC_INDEX21:
3205         case MHL_VIC_INDEX22:
3206         case MHL_VIC_INDEX31:
3207             ucFrameRate = 50;
3208             break;
3209 
3210         case MHL_VIC_INDEX34:
3211         case MHL_VIC_INDEX95:
3212         case MHL_VIC_INDEX100:
3213             ucFrameRate = 30;
3214             break;
3215 
3216         case MHL_VIC_INDEX63:
3217             ucFrameRate = 120;
3218             break;
3219 
3220         case MHL_VIC_INDEX64:
3221             ucFrameRate = 100;
3222             break;
3223 
3224         case MHL_VIC_INDEX93:
3225         case MHL_VIC_INDEX98:
3226             ucFrameRate = 24;
3227             break;
3228 
3229         case MHL_VIC_INDEX94:
3230         case MHL_VIC_INDEX99:
3231             ucFrameRate = 25;
3232             break;
3233 
3234         default:
3235 
3236             break;
3237     };
3238 
3239     return ucFrameRate;
3240 }
3241 
3242 //**************************************************************************
3243 //  [Function Name]:
3244 //                  _mdrv_mhl_ParsingWriteBurstBISTSetup()
3245 //  [Description]:
3246 //
3247 //  [Arguments]:
3248 //
3249 //  [Return]:
3250 //
3251 //**************************************************************************
_mdrv_mhl_ParsingWriteBurstBISTSetup(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate)3252 void _mdrv_mhl_ParsingWriteBurstBISTSetup(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate)
3253 {
3254     MS_U8 ucReadyIndex = 0x70;
3255     MS_U8 ucBISTeCbusPattern = pMHLResourcePrivate->ucDeviceCapabilityTable[MHL_CBUS_ECBUS_SPEEDS];
3256     MS_U8 ucBISTAVLinkRate = pMHLResourcePrivate->ucDeviceCapabilityTable[MHL_CBUS_TMDS_SPEEDS];
3257     MS_U16 usBISTeCbusPatternFixed = 0;
3258     MS_U16 usBISTAVLinkFixed = 0;
3259     MS_U16 usBISTeCbusDuration = 0;
3260     MS_U16 usBISTAVLinkDuration = 0;
3261 
3262     // ucWriteBurstInformation[0]: BIST_SETUP_H
3263     // ucWriteBurstInformation[1]: BIST_SETUP_L
3264     // ucWriteBurstInformation[2]: CHECK_SUM
3265     // ucWriteBurstInformation[3]: eCBUS_DURATION
3266     // ucWriteBurstInformation[4]: eCBUS_PATTERN
3267     // ucWriteBurstInformation[5]: eCBUS_FIXED_H
3268     // ucWriteBurstInformation[6]: eCBUS_FIXED_L
3269     // ucWriteBurstInformation[7]: Reserved
3270     // ucWriteBurstInformation[8]: AV LINK_DATA_RATE
3271     // ucWriteBurstInformation[9]: AV LINK_PATTERN
3272     // ucWriteBurstInformation[10]: AV LINK_VIDEO_MODE
3273     // ucWriteBurstInformation[11]: AV LINK_DURATION
3274     // ucWriteBurstInformation[12]: AV LINK_FIXED_H
3275     // ucWriteBurstInformation[13]: AV LINK_FIXED_L
3276     // ucWriteBurstInformation[14]: AV LINK_RANDOMIZER
3277     // ucWriteBurstInformation[15]: IMPEDANCE_MODE
3278 
3279     if((ucBISTeCbusPattern &BIT(4)) == BIT(4)) // MHL_ECBUS_D_150
3280     {
3281         ucBISTeCbusPattern = MHL_BIST_ECBUS_PATTERN_FIXED10;
3282     }
3283     else if((ucBISTeCbusPattern &BIT(0)) == BIT(0)) // MHL_ECBUS_S_075
3284     {
3285         ucBISTeCbusPattern = MHL_BIST_ECBUS_PATTERN_FIXED8;
3286     }
3287     else
3288     {
3289         ucBISTeCbusPattern = MHL_BIST_ECBUS_PATTERN_PRBS;
3290     }
3291 
3292     if((ucBISTAVLinkRate & BIT(2)) == BIT(2)) // MHL_TMDS_600
3293     {
3294         ucBISTAVLinkRate = MHL_BIST_AV_LINK_600;
3295     }
3296     else if((ucBISTAVLinkRate & BIT(1)) == BIT(1)) // MHL_TMDS_300
3297     {
3298         ucBISTAVLinkRate = MHL_BIST_AV_LINK_300;
3299     }
3300     else if((ucBISTAVLinkRate & BIT(0)) == BIT(0)) // MHL_TMDS_150
3301     {
3302         ucBISTAVLinkRate = MHL_BIST_AV_LINK_150;
3303     }
3304     else
3305     {
3306         ucBISTAVLinkRate = MHL_BIST_AV_LINK_RESERVED;
3307     }
3308 
3309     if(pMHLResourcePrivate->ucWriteBurstInformation[4] <= ucBISTeCbusPattern) // Check eCbus pattern
3310     {
3311        ucReadyIndex = MASKSET(ucReadyIndex, BIT(0), (BIT(0) |BIT(4)));
3312 
3313        ucBISTeCbusPattern = pMHLResourcePrivate->ucWriteBurstInformation[4];
3314        usBISTeCbusPatternFixed = ((MS_U16)pMHLResourcePrivate->ucWriteBurstInformation[5] <<8) |pMHLResourcePrivate->ucWriteBurstInformation[6];
3315     }
3316 
3317     if(pMHLResourcePrivate->ucWriteBurstInformation[8] <= ucBISTAVLinkRate) // Check AV link rate
3318     {
3319         ucReadyIndex = MASKSET(ucReadyIndex, BIT(1), (BIT(1) |BIT(5)));
3320 
3321         ucBISTAVLinkRate = pMHLResourcePrivate->ucWriteBurstInformation[8];
3322         usBISTAVLinkFixed = ((MS_U16)pMHLResourcePrivate->ucWriteBurstInformation[12] <<8) |pMHLResourcePrivate->ucWriteBurstInformation[13];
3323     }
3324 
3325     //if() // Unknow condition
3326     {
3327         ucReadyIndex = MASKSET(ucReadyIndex, BIT(2), (BIT(2) |BIT(6)));
3328     }
3329 
3330     if(pMHLResourcePrivate->ucWriteBurstInformation[3] == 0) // Check eCbus duration
3331     {
3332         // Can't allow
3333     }
3334     else
3335     {
3336         usBISTeCbusDuration = (MS_U16)pMHLResourcePrivate->ucWriteBurstInformation[3] *1010ul;
3337     }
3338 
3339     if(pMHLResourcePrivate->ucWriteBurstInformation[9] <= MHL_BIST_LINK_PATTERN_FIXED8)
3340     {
3341         usBISTAVLinkDuration = ((MS_U16)pMHLResourcePrivate->ucWriteBurstInformation[11] *32 /_mdrv_mhl_CheckAVLineVideoMode(pMHLResourcePrivate->ucWriteBurstInformation[10]) +1) *1000;
3342     }
3343     else if(pMHLResourcePrivate->ucWriteBurstInformation[9] == MHL_BIST_LINK_PATTERN_FIXED10)
3344     {
3345         usBISTAVLinkDuration = (MS_U16)pMHLResourcePrivate->ucWriteBurstInformation[11] *1010ul;
3346     }
3347 
3348     pMHLResourcePrivate->stBISTParameterInfo.ucBISTReadyIndex = ucReadyIndex;
3349     pMHLResourcePrivate->stBISTParameterInfo.ucBISTeCbusPattern = ucBISTeCbusPattern;
3350     pMHLResourcePrivate->stBISTParameterInfo.usBISTeCbusPatternFixed = usBISTeCbusPatternFixed;
3351     pMHLResourcePrivate->stBISTParameterInfo.usBISTeCbusDuration = usBISTeCbusDuration;
3352     pMHLResourcePrivate->stBISTParameterInfo.ucBISTAVLinkRate = ucBISTAVLinkRate;
3353     pMHLResourcePrivate->stBISTParameterInfo.ucBISTAVLinkPattern = pMHLResourcePrivate->ucWriteBurstInformation[9];
3354     pMHLResourcePrivate->stBISTParameterInfo.usBISTAVLinkFixed = usBISTAVLinkFixed;
3355     pMHLResourcePrivate->stBISTParameterInfo.usBISTAVLinkDuration = usBISTAVLinkDuration;
3356     pMHLResourcePrivate->stBISTParameterInfo.ucBISTAVLinkRateRandomizer = pMHLResourcePrivate->ucWriteBurstInformation[14];
3357     pMHLResourcePrivate->stBISTParameterInfo.ucBISTImpedanceMode = pMHLResourcePrivate->ucWriteBurstInformation[15];
3358 
3359 #if(MHL_DEBUG_BIST_MODE)
3360     MDRV_MHL_MSG_INFO("** MHL BIST eCbus pattern = %d\r\n", pMHLResourcePrivate->stBISTParameterInfo.ucBISTeCbusPattern);
3361     MDRV_MHL_MSG_INFO("** MHL BIST eCbus fixed = %x\r\n", pMHLResourcePrivate->stBISTParameterInfo.usBISTeCbusPatternFixed);
3362     MDRV_MHL_MSG_INFO("** MHL BIST eCbus duration = %d\r\n", pMHLResourcePrivate->stBISTParameterInfo.usBISTeCbusDuration);
3363     MDRV_MHL_MSG_INFO("** MHL BIST AV link rate = %d\r\n", pMHLResourcePrivate->stBISTParameterInfo.ucBISTAVLinkRate);
3364     MDRV_MHL_MSG_INFO("** MHL BIST AV link pattern = %d\r\n", pMHLResourcePrivate->stBISTParameterInfo.ucBISTAVLinkPattern);
3365     MDRV_MHL_MSG_INFO("** MHL BIST AV link fixed = %x\r\n", pMHLResourcePrivate->stBISTParameterInfo.usBISTAVLinkFixed);
3366     MDRV_MHL_MSG_INFO("** MHL BIST AV link duration = %d\r\n", pMHLResourcePrivate->stBISTParameterInfo.usBISTAVLinkDuration);
3367     MDRV_MHL_MSG_INFO("** MHL BIST AV link random = %d\r\n", pMHLResourcePrivate->stBISTParameterInfo.ucBISTAVLinkRateRandomizer);
3368     MDRV_MHL_MSG_INFO("** MHL BIST Impedance mode = %d\r\n", pMHLResourcePrivate->stBISTParameterInfo.ucBISTImpedanceMode);
3369 #endif
3370 }
3371 
3372 //**************************************************************************
3373 //  [Function Name]:
3374 //                  _mdrv_mhl_ParsingWriteBurstInformation()
3375 //  [Description]:
3376 //
3377 //  [Arguments]:
3378 //
3379 //  [Return]:
3380 //
3381 //**************************************************************************
_mdrv_mhl_ParsingWriteBurstInformation(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate)3382 void _mdrv_mhl_ParsingWriteBurstInformation(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate)
3383 {
3384     MS_U8 uctemp = 0;
3385     MS_U8 ucCheckSum = 0;
3386     MS_U16 usWriteBurstID = ((MS_U16)pMHLResourcePrivate->ucWriteBurstInformation[0] <<8) |pMHLResourcePrivate->ucWriteBurstInformation[1];
3387 
3388     for(uctemp = 0; uctemp <MHL_MSC_SCRATCHPAD_SIZE; uctemp++)
3389     {
3390         ucCheckSum = ucCheckSum +pMHLResourcePrivate->ucWriteBurstInformation[uctemp];
3391     }
3392 
3393     if(ucCheckSum == 0)
3394     {
3395         switch(usWriteBurstID)
3396         {
3397             case MHL_BURST_ID_VC_ASSIGN:
3398                 if(_mdrv_mhl_ParsingWriteBurstVCAssign(pMHLResourcePrivate))
3399                 {
3400                     SET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_VC_ASSIGN_FLAG);
3401                 }
3402                 break;
3403 
3404             case MHL_BURST_ID_VC_CONFIRM:
3405                 _mdrv_mhl_ParsingWriteBurstVCConfirm(pMHLResourcePrivate);
3406                 break;
3407 
3408             case MHL_BURST_ID_BIST_SETUP:
3409                 pMHLResourcePrivate->ucBISTModeState = MHL_CBUS_BIST_RECEIVE_SETUP;
3410 
3411                 _mdrv_mhl_ParsingWriteBurstBISTSetup(pMHLResourcePrivate);
3412 
3413                 break;
3414 
3415             default:
3416 
3417                 break;
3418         };
3419     }
3420     else
3421     {
3422         MDRV_MHL_MSG_INFO("** MHL write burst check sum error port %c\r\n", MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath));
3423     }
3424 }
3425 
3426 //**************************************************************************
3427 //  [Function Name]:
3428 //                  _mdrv_mhl_CbusBISTTriggerProc()
3429 //  [Description]
3430 //
3431 //  [Arguments]:
3432 //
3433 //  [Return]:
3434 //
3435 //**************************************************************************
_mdrv_mhl_CbusBISTTriggerProc(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate,MS_U8 ucKeyCode)3436 void _mdrv_mhl_CbusBISTTriggerProc(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate, MS_U8 ucKeyCode)
3437 {
3438     MS_BOOL bGeteCbusDuration = FALSE;
3439     MS_BOOL bGetAVLinkDuration = FALSE;
3440     MS_U8 ucBISTDeviceType = pMHLResourcePrivate->ucDeviceCapabilityTable[MHL_CBUS_DEV_CAT] &BMASK(3:0);
3441     MS_U8 ucBISTeCbusSelect = pMHLResourcePrivate->ucDeviceCapabilityTable[MHL_CBUS_ECBUS_SPEEDS];
3442     MS_U16 usTimerCount = 0;
3443 
3444     if(((ucKeyCode &BIT(3)) == BIT(3)) && ((ucBISTeCbusSelect &BIT(4)) != BIT(4))) // Not support eCbus-D
3445     {
3446         // Chip only support eCbus-S
3447     }
3448 
3449     if((ucKeyCode &BIT(0)) == BIT(0)) // Source device and eCbus Tx
3450     {
3451         bGeteCbusDuration = TRUE;
3452 
3453         pMHLResourcePrivate->stBISTParameterInfo.bBISTeCbusTxFlag = TRUE;
3454     }
3455     else
3456     {
3457         pMHLResourcePrivate->stBISTParameterInfo.bBISTeCbusTxFlag = FALSE;
3458     }
3459 
3460     if((ucKeyCode &BIT(1)) == BIT(1)) // Sink device and eCbus link Rx
3461     {
3462         bGeteCbusDuration = TRUE;
3463 
3464         pMHLResourcePrivate->stBISTParameterInfo.bBISTeCbusRxFlag = TRUE;
3465     }
3466     else
3467     {
3468         pMHLResourcePrivate->stBISTParameterInfo.bBISTeCbusRxFlag = FALSE;
3469     }
3470 
3471     if((ucBISTDeviceType == MHL_DEVICE_SOURCE) || (ucBISTDeviceType == MHL_DEVICE_DIRECT_ATTACH_SOURCE))
3472     {
3473         if((ucKeyCode &BIT(4)) == BIT(4)) // Source device and AV link Tx
3474         {
3475 
3476         }
3477     }
3478     else if((ucBISTDeviceType == MHL_DEVICE_SINK) || (ucBISTDeviceType == MHL_DEVICE_DIRECT_ATTACH_SINK))
3479     {
3480         if((ucKeyCode &BIT(6)) == BIT(6)) // Impedance test
3481         {
3482             bGeteCbusDuration = TRUE;
3483         }
3484 
3485         if((ucKeyCode &BIT(5)) == BIT(5)) // Sink device and AV link Rx
3486         {
3487             bGetAVLinkDuration = TRUE;
3488         }
3489     }
3490 
3491     if(pMHLResourcePrivate->ucBISTModeState == MHL_CBUS_BIST_WAIT_TRIGGER)
3492     {
3493         if(bGeteCbusDuration)
3494         {
3495             usTimerCount = pMHLResourcePrivate->stBISTParameterInfo.usBISTeCbusDuration;
3496         }
3497 
3498         if(bGetAVLinkDuration)
3499         {
3500             if(usTimerCount < pMHLResourcePrivate->stBISTParameterInfo.usBISTAVLinkDuration)
3501             {
3502                 usTimerCount = pMHLResourcePrivate->stBISTParameterInfo.usBISTAVLinkDuration;
3503             }
3504         }
3505 
3506         if(bGeteCbusDuration || bGetAVLinkDuration)
3507         {
3508             pMHLResourcePrivate->ucBISTModeState = MHL_CBUS_BIST_RECEIVE_TRIGGER;
3509             pMHLResourcePrivate->stBISTParameterInfo.usBISTeCbusDuration = usTimerCount;
3510         }
3511     }
3512 
3513     MDRV_MHL_MSG_INFO("** MHL receive BIST trigger in port %c keycode %x\r\n", MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath), ucKeyCode);
3514 }
3515 
3516 //**************************************************************************
3517 //  [Function Name]:
3518 //                  _mdrv_mhl_CbusBISTRequestStatusProc()
3519 //  [Description]
3520 //
3521 //  [Arguments]:
3522 //
3523 //  [Return]:
3524 //
3525 //**************************************************************************
_mdrv_mhl_CbusBISTRequestStatusProc(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate,MS_U8 ucKeyCode)3526 void _mdrv_mhl_CbusBISTRequestStatusProc(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate, MS_U8 ucKeyCode)
3527 {
3528     //if(ucKeyCode == MHL_BIST_REQ_RETURN_STATUS)
3529     {
3530         pMHLResourcePrivate->ucBISTModeState = MHL_CBUS_BIST_REQUEST_STATUS;
3531     }
3532 
3533     MDRV_MHL_MSG_INFO("** MHL receive BIST request status in port %c keycode %x\r\n", MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath), ucKeyCode);
3534 }
3535 
3536 //**************************************************************************
3537 //  [Function Name]:
3538 //                  _mdrv_mhl_CbusBISTStopProc()
3539 //  [Description]
3540 //                  Disable AV LINK_BIST when currently running
3541 //  [Arguments]:
3542 //
3543 //  [Return]:
3544 //
3545 //**************************************************************************
_mdrv_mhl_CbusBISTStopProc(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate,MS_U8 ucKeyCode)3546 void _mdrv_mhl_CbusBISTStopProc(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate, MS_U8 ucKeyCode)
3547 {
3548     if(ucKeyCode == 0) // Key code must be set to 0
3549     {
3550         if(pMHLResourcePrivate->ucBISTModeState == MHL_CBUS_BIST_ECBUS_SWITCH)
3551         {
3552             pMHLResourcePrivate->ucBISTModeState = MHL_CBUS_BIST_EVENT_FINISH;
3553         }
3554     }
3555 
3556     MDRV_MHL_MSG_INFO("** MHL receive BIST stop in port %c keycode %x\r\n", MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath), ucKeyCode);
3557 }
3558 
3559 //**************************************************************************
3560 //  [Function Name]:
3561 //                  _mdrv_mhl_CbusReceiveEventProc()
3562 //  [Description]:
3563 //
3564 //  [Arguments]:
3565 //
3566 //  [Return]:
3567 //
3568 //**************************************************************************
_mdrv_mhl_CbusReceiveEventProc(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate)3569 void _mdrv_mhl_CbusReceiveEventProc(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate)
3570 {
3571     MS_U8 ucQueueIndex = 0;
3572     MS_U16 usTimeTick = MHL_CBUS_IDEL_FREE_TIME;
3573 
3574     if(GET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_MSC_FLAG))
3575     {
3576         CLR_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_MSC_FLAG);
3577 
3578         if(GET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_ABORT_FLAG))
3579         {
3580             CLR_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_ABORT_FLAG);
3581 
3582             usTimeTick = MHL_CBUS_ABORT_HOLD_TIME;
3583         }
3584 
3585         _mdrv_mhl_SetCbusTimerEvent(pMHLResourcePrivate, MHL_TIMER_EVENT_CBUS_SILENCE, usTimeTick);
3586     }
3587 
3588     if(GET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_ACK_FLAG))
3589     {
3590         CLR_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_ACK_FLAG);
3591 
3592         if(pMHLResourcePrivate->stCbusQueueInfo[MHL_CBUS_RX_QUEUE_INDEX].ucQueueState != MHL_QUEUE_STATE_IDLE)
3593         {
3594             pMHLResourcePrivate->stCbusQueueInfo[MHL_CBUS_RX_QUEUE_INDEX].ucQueueState = MHL_QUEUE_STATE_IDLE;
3595         }
3596         else if(pMHLResourcePrivate->stCbusQueueInfo[pMHLResourcePrivate->ucCurrentQueueIndex].ucQueueState != MHL_QUEUE_STATE_PENDING)
3597         {
3598             pMHLResourcePrivate->stCbusQueueInfo[pMHLResourcePrivate->ucCurrentQueueIndex].ucQueueState = MHL_QUEUE_STATE_IDLE;
3599         }
3600 
3601         ucQueueIndex = _mdrv_mhl_GetCbusQueueIndex(pMHLResourcePrivate);
3602 
3603         // Update current index to search index, but not Rx queue index
3604         if(ucQueueIndex < MHL_CBUS_RX_QUEUE_INDEX)
3605         {
3606             pMHLResourcePrivate->ucCurrentQueueIndex = ucQueueIndex;
3607         }
3608 
3609         _mdrv_mhl_CbusDisplayLinkCheck(pMHLResourcePrivate);
3610     }
3611 
3612     if(GET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_24BIT_MODE_FLAG))
3613     {
3614         CLR_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_24BIT_MODE_FLAG);
3615 
3616         if(pMHLResourcePrivate->ucTMDSClockMode == MHL_PHY_CLOCK_PACKET_PIXEL)
3617         {
3618             mhal_mhl_ClockModeSwitchProc(pMHLResourcePrivate->ucMHLSupportPath, FALSE, &(pMHLResourcePrivate->stSignalStatusInfo));
3619 
3620             MDRV_MHL_MSG_INFO("** MHL switch back to 24 bits mode port %c\r\n", MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath));
3621 
3622             pMHLResourcePrivate->ucTMDSClockMode = MHL_PHY_CLOCK_NORMAL_24BIT;
3623         }
3624     }
3625 
3626     if(GET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_PP_MODE_FLAG))
3627     {
3628         CLR_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_PP_MODE_FLAG);
3629 
3630         if(pMHLResourcePrivate->ucTMDSClockMode == MHL_PHY_CLOCK_NORMAL_24BIT)
3631         {
3632             mhal_mhl_ClockModeSwitchProc(pMHLResourcePrivate->ucMHLSupportPath, TRUE, &(pMHLResourcePrivate->stSignalStatusInfo));
3633 
3634             MDRV_MHL_MSG_INFO("** MHL switch to packet pixel mode port %c\r\n", MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath));
3635 
3636             pMHLResourcePrivate->ucTMDSClockMode = MHL_PHY_CLOCK_PACKET_PIXEL;
3637         }
3638     }
3639 
3640     if(GET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_MHL3_VERSION_FLAG))
3641     {
3642         CLR_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_MHL3_VERSION_FLAG);
3643 
3644         if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CBUS_ENHANCE_FLAG))
3645         {
3646             SET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_ECBUS_FUNCTION_FLAG);
3647         }
3648     }
3649 
3650     if(GET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_WRITE_GRANT_FLAG))
3651     {
3652         CLR_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_WRITE_GRANT_FLAG);
3653 
3654         if(pMHLResourcePrivate->ucWriteBurstState == MHL_CBUS_WRITE_BURST_SEND_REQUEST)
3655         {
3656             pMHLResourcePrivate->ucWriteBurstState = MHL_CBUS_WRITE_BURST_REVEIVE_GRANT;
3657         }
3658     }
3659 
3660     if(GET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_3D_REQ_FLAG))
3661     {
3662         if(GET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_3D_INFORMATION_FLAG))
3663         {
3664             CLR_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_3D_REQ_FLAG);
3665         }
3666         else if(pMHLResourcePrivate->ucWriteBurstState == MHL_CBUS_WRITE_BURST_NONE)
3667         {
3668             CLR_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_3D_REQ_FLAG);
3669             SET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_3D_INFORMATION_FLAG);
3670             SET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_3D_DTD_FLAG);
3671             SET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_3D_VIC_FLAG);
3672         }
3673     }
3674 
3675     if(GET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_DSCR_CHANGE_FLAG))
3676     {
3677         CLR_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_DSCR_CHANGE_FLAG);
3678 
3679         pMHLResourcePrivate->ucWriteBurstState = MHL_CBUS_WRITE_BURST_END;
3680     }
3681 
3682     if(GET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_FEATURE_REQUEST_FLAG))
3683     {
3684         CLR_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_FEATURE_REQUEST_FLAG);
3685 
3686         if(pMHLResourcePrivate->ucFeatureRequestState == MHL_CBUS_FEATURE_NONE)
3687         {
3688             pMHLResourcePrivate->ucFeatureRequestState = MHL_CBUS_FEATURE_START;
3689         }
3690     }
3691 
3692     if(GET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_FEATURE_COMPLETE_FLAG))
3693     {
3694         CLR_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_FEATURE_COMPLETE_FLAG);
3695 
3696         if(pMHLResourcePrivate->ucFeatureRequestState == MHL_CBUS_FEATURE_SEND_FEATURE_REQUEST)
3697         {
3698             pMHLResourcePrivate->ucFeatureRequestState = MHL_CBUS_FEATURE_END;
3699         }
3700     }
3701 
3702     if(GET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_LINK_RATE_FLAG))
3703     {
3704         CLR_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_LINK_RATE_FLAG);
3705         SET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_LINK_STATUS_NORMAL_FLAG);
3706 
3707         if(pMHLResourcePrivate->stSignalStatusInfo.ucMainLinkRate < MHL_AV_LINK_NONE)
3708         {
3709             mhal_mhl_SetMainLinkRate(pMHLResourcePrivate->ucMHLSupportPath, pMHLResourcePrivate->stSignalStatusInfo.ucMainLinkRate);
3710 
3711             mhal_mhl_CDRModeMonitor(pMHLResourcePrivate->ucMHLSupportPath, FALSE, &(pMHLResourcePrivate->stSignalStatusInfo));
3712 
3713             MDRV_MHL_MSG_INFO("** MHL set AV link rate mode %d port %c\r\n", pMHLResourcePrivate->stSignalStatusInfo.ucMainLinkRate, MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath));
3714         }
3715     }
3716 
3717     if(GET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_WRITE_BURST_FLAG))
3718     {
3719         CLR_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_WRITE_BURST_FLAG);
3720 
3721         _mdrv_mhl_ParsingWriteBurstInformation(pMHLResourcePrivate);
3722     }
3723 
3724     if(GET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_VC_ASSIGN_FLAG))
3725     {
3726         CLR_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_VC_ASSIGN_FLAG);
3727         SET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_VC_INFORMATION_FLAG);
3728         SET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_VC_CONFIRM_FLAG);
3729     }
3730 
3731     if(GET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_ECBUS_MODE_FLAG))
3732     {
3733         CLR_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_ECBUS_MODE_FLAG);
3734 
3735         if(!GET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_CBUS1_FUNCTION_FLAG))
3736         {
3737             SET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_CBUS_TX_QUEUE_FREEZE_FLAG);
3738 
3739             _mdrv_mhl_SetCbusTimerEvent(pMHLResourcePrivate, MHL_TIMER_EVENT_TX_QUQUE_FREEZE, MHL_CBUS_1_SECOND_TIME);
3740 
3741             MDRV_MHL_MSG_INFO("** MHL CTS 6.3.9.1 patch port %c\r\n", MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath));
3742         }
3743     }
3744 }
3745 
3746 //**************************************************************************
3747 //  [Function Name]:
3748 //                  _mdrv_mhl_CbusMSGEventProc()
3749 //  [Description]:
3750 //
3751 //  [Arguments]:
3752 //
3753 //  [Return]:
3754 //
3755 //**************************************************************************
_mdrv_mhl_CbusMSGEventProc(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate)3756 void _mdrv_mhl_CbusMSGEventProc(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate)
3757 {
3758     MS_BOOL bReceiveResponse = FALSE;
3759     MS_BOOL bResponseErrorFlag = FALSE;
3760     MS_U8 ucStatus = MHL_RCP_NO_ERROR;
3761     MS_U8 ucSubCommand = 0;
3762     MS_U8 ucKeyCode = MHL_RCP_NO_ERROR;
3763 
3764     if(GET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_MSG_FLAG))
3765     {
3766         CLR_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_MSG_FLAG);
3767 
3768         switch(pMHLResourcePrivate->ucMSGData[0])
3769         {
3770             case MSC_MSG_MSGE:
3771 
3772                 break;
3773 
3774             case MSC_MSG_RCP:
3775                 if(!GET_MHL_CALLBACK_FLAG(pMHLResourcePrivate->ucCallBackFunctionIndex, MHL_CALLBACK_RCP_FUNCTION_FLAG))
3776                 {
3777                     ucStatus = MHL_RCP_NO_ERROR;
3778 
3779                     MDRV_MHL_MSG_WARNING("** MHL RCP call back NULL port %c\r\n", MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath));
3780                 }
3781                 else if(!(pMHLResourcePrivate->ucMSGData[1] &BIT(7))) // Ignore release key
3782                 {
3783                     SET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_CALLBACK_FUNCTION_FLAG);
3784                 }
3785 
3786                 if(ucStatus == MHL_RCP_NO_ERROR)
3787                 {
3788                     ucSubCommand = MSC_MSG_RCPK;
3789                     ucKeyCode = pMHLResourcePrivate->ucMSGData[1];
3790                 }
3791                 else
3792                 {
3793                     ucSubCommand = MSC_MSG_RCPE;
3794                     ucKeyCode = ucStatus;
3795 
3796                     pMHLResourcePrivate->ucMSGData[0] = MSC_MSG_RCPK;
3797                     bResponseErrorFlag = TRUE;
3798                 }
3799 
3800                 _mdrv_mhl_CbusRxQueueInsertMSG(pMHLResourcePrivate, ucSubCommand, ucKeyCode);
3801 
3802                 break;
3803 
3804             case MSC_MSG_RCPK:
3805             case MSC_MSG_RCPE:
3806                 bReceiveResponse = TRUE;
3807                 break;
3808 
3809             case MSC_MSG_RAP:
3810                 if(!GET_MHL_CALLBACK_FLAG(pMHLResourcePrivate->ucCallBackFunctionIndex, MHL_CALLBACK_RAP_FUNCTION_FLAG))
3811                 {
3812                     ucStatus = MHL_RAP_NO_ERROR;
3813 
3814                     MDRV_MHL_MSG_WARNING("** MHL RAP call back NULL port %c\r\n", MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath));
3815                 }
3816                 else if(_mdrv_mhl_CheckCbusModeChange(pMHLResourcePrivate))
3817                 {
3818                     if(_mdrv_mhl_GetRAPEnableFlag(pMHLResourcePrivate))
3819                     {
3820                         SET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_CALLBACK_FUNCTION_FLAG);
3821                     }
3822 
3823                     ucSubCommand = MSC_MSG_RAPK;
3824                     ucKeyCode = ucStatus;
3825 
3826                     _mdrv_mhl_CbusRxQueueInsertMSG(pMHLResourcePrivate, ucSubCommand, ucKeyCode);
3827                 }
3828                 else if(GET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_CBUS_TX_QUEUE_FREEZE_FLAG))
3829                 {
3830                     CLR_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_CBUS_TX_QUEUE_FREEZE_FLAG);
3831                 }
3832 
3833                 break;
3834 
3835             case MSC_MSG_RAPK:
3836                 bReceiveResponse = TRUE;
3837                 break;
3838 
3839             case MSC_MSG_UCP:
3840                 if(!GET_MHL_CALLBACK_FLAG(pMHLResourcePrivate->ucCallBackFunctionIndex, MHL_CALLBACK_UCP_FUNCTION_FLAG))
3841                 {
3842                     ucStatus = MHL_UCP_NO_ERROR;
3843 
3844                     MDRV_MHL_MSG_WARNING("** MHL UCP call back NULL port %c\r\n", MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath));
3845                 }
3846                 else
3847                 {
3848                     SET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_CALLBACK_FUNCTION_FLAG);
3849                 }
3850 
3851                 if(ucStatus == MHL_UCP_NO_ERROR)
3852                 {
3853                     ucSubCommand = MSC_MSG_UCPK;
3854                     ucKeyCode = pMHLResourcePrivate->ucMSGData[1];
3855                 }
3856                 else
3857                 {
3858                     ucSubCommand = MSC_MSG_UCPE;
3859                     ucKeyCode = ucStatus;
3860 
3861                     pMHLResourcePrivate->ucMSGData[0] = MSC_MSG_UCPK;
3862                     bResponseErrorFlag = TRUE;
3863                 }
3864 
3865                 _mdrv_mhl_CbusRxQueueInsertMSG(pMHLResourcePrivate, ucSubCommand, ucKeyCode);
3866 
3867                 break;
3868 
3869             case MSC_MSG_UCPK:
3870             case MSC_MSG_UCPE:
3871                 bReceiveResponse = TRUE;
3872                 break;
3873 
3874             case MSC_MSG_ATT:
3875                 if(!GET_MHL_CALLBACK_FLAG(pMHLResourcePrivate->ucCallBackFunctionIndex, MHL_CALLBACK_ATT_FUNCTION_FLAG))
3876                 {
3877                     ucStatus = MHL_ATT_NO_ERROR;
3878 
3879                     MDRV_MHL_MSG_WARNING("** MHL ATT call back NULL port %c\r\n", MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath));
3880                 }
3881                 else
3882                 {
3883                     SET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_CALLBACK_FUNCTION_FLAG);
3884                 }
3885 
3886                 ucSubCommand = MSC_MSG_ATTK;
3887                 ucKeyCode = ucStatus;
3888 
3889                 _mdrv_mhl_CbusRxQueueInsertMSG(pMHLResourcePrivate, ucSubCommand, ucKeyCode);
3890 
3891                 break;
3892 
3893             case MSC_MSG_ATTK:
3894                 bReceiveResponse = TRUE;
3895                 break;
3896 
3897             case MSC_MSG_RBP:
3898                 if(!GET_MHL_CALLBACK_FLAG(pMHLResourcePrivate->ucCallBackFunctionIndex, MHL_CALLBACK_RBP_FUNCTION_FLAG))
3899                 {
3900                     ucStatus = MHL_RBP_NO_ERROR;
3901 
3902                     MDRV_MHL_MSG_WARNING("** MHL RBP call back NULL port %c\r\n", MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath));
3903                 }
3904                 else
3905                 {
3906                     SET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_CALLBACK_FUNCTION_FLAG);
3907                 }
3908 
3909                 if(ucStatus == MHL_RBP_NO_ERROR)
3910                 {
3911                     ucSubCommand = MSC_MSG_RBPK;
3912                     ucKeyCode = pMHLResourcePrivate->ucMSGData[1];
3913                 }
3914                 else
3915                 {
3916                     ucSubCommand = MSC_MSG_RBPE;
3917                     ucKeyCode = ucStatus;
3918 
3919                     pMHLResourcePrivate->ucMSGData[0] = MSC_MSG_RBPK;
3920                     bResponseErrorFlag = TRUE;
3921                 }
3922 
3923                 _mdrv_mhl_CbusRxQueueInsertMSG(pMHLResourcePrivate, ucSubCommand, ucKeyCode);
3924 
3925                 break;
3926 
3927             case MSC_MSG_RBPK:
3928             case MSC_MSG_RBPE:
3929                 bReceiveResponse = TRUE;
3930                 break;
3931 
3932             case MSC_MSG_RUSB:
3933 
3934                 break;
3935 
3936             case MSC_MSG_RUSBK:
3937                 bReceiveResponse = TRUE;
3938                 break;
3939 
3940             case MSC_MSG_RHID:
3941 
3942                 break;
3943 
3944             case MSC_MSG_RHIDK:
3945                 bReceiveResponse = TRUE;
3946                 break;
3947 
3948             case MSC_MSG_BIST_TRIGGRT:
3949                 _mdrv_mhl_CbusBISTTriggerProc(pMHLResourcePrivate, pMHLResourcePrivate->ucMSGData[1]);
3950                 break;
3951 
3952             case MSC_MSG_BIST_REQUEST_STAT:
3953                 _mdrv_mhl_CbusBISTRequestStatusProc(pMHLResourcePrivate, pMHLResourcePrivate->ucMSGData[1]);
3954                 break;
3955 
3956             case MSC_MSG_BIST_STOP:
3957                 _mdrv_mhl_CbusBISTStopProc(pMHLResourcePrivate, pMHLResourcePrivate->ucMSGData[1]);
3958                 break;
3959 
3960             case MSC_MSG_SI_UNKNOWN:
3961                 _mdrv_mhl_CbusSendSubMessage(pMHLResourcePrivate, MSC_MSG_SI_UNKNOWNK, 0, FALSE);
3962                 break;
3963 
3964             default:
3965                 if(pMHLResourcePrivate->ucMSGData[0] < 0x20) // For CTS 6.3.11.23
3966                 {
3967                     _mdrv_mhl_CbusSendSubMessage(pMHLResourcePrivate, MSC_MSG_MSGE, MHL_MSGE_INVALID_SUB_COMMAND_CODE, FALSE);
3968                 }
3969 
3970                 break;
3971         };
3972 
3973         if(bReceiveResponse)
3974         {
3975             CLR_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_MSG_COMMAND_FLAG);
3976         }
3977 
3978         if(bResponseErrorFlag)
3979         {
3980             _mdrv_mhl_SetCbusTimerEvent(pMHLResourcePrivate, MHL_TIMER_EVENT_SEND_MSG_RESPONSE, MHL_MSG_SEND_RESPONSE_TIME);
3981         }
3982     }
3983 }
3984 
3985 //**************************************************************************
3986 //  [Function Name]:
3987 //                  _mdrv_mhl_EMSCParsingEMSCSupport()
3988 //  [Description]:
3989 //
3990 //  [Arguments]:
3991 //
3992 //  [Return]:
3993 //
3994 //**************************************************************************
_mdrv_mhl_EMSCParsingEMSCSupport(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate,MS_U8 * bReveiceEMSC)3995 MS_U8 _mdrv_mhl_EMSCParsingEMSCSupport(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate, MS_U8 *bReveiceEMSC)
3996 {
3997     MS_U8 ucLength = bReveiceEMSC[3] *MHL_EMSC_SUPPORT_ITEM_LENGTH +6;
3998 
3999     if(pMHLResourcePrivate != NULL)
4000     {
4001 
4002     }
4003 
4004     return ucLength;
4005 }
4006 
4007 //**************************************************************************
4008 //  [Function Name]:
4009 //                  _mdrv_mhl_ParsingEMSCReceiveData()
4010 //  [Description]:
4011 //
4012 //  [Arguments]:
4013 //
4014 //  [Return]:
4015 //
4016 //**************************************************************************
_mdrv_mhl_ParsingEMSCReceiveData(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate)4017 void _mdrv_mhl_ParsingEMSCReceiveData(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate)
4018 {
4019     MS_U8 uctemp = 3;
4020     MS_U8 ucReceiveEMSC[MHL_EMSC_DATA_SIZE +1] = {0};
4021     MS_U16 usEMSCRxBufferSize = 0;
4022     MS_U16 usEMSCTxBufferSize = 0;
4023     MS_U16 usWriteBurstID = 0;
4024 
4025     mhal_mhl_GetEMSCReceiveData(ucReceiveEMSC);
4026 
4027     usEMSCTxBufferSize = ucReceiveEMSC[1]; // Rx unload ACK
4028 
4029     if(ucReceiveEMSC[2] > 0) // Check length remaining
4030     {
4031         while((ucReceiveEMSC[2] +3) > uctemp)
4032         {
4033             usWriteBurstID = (ucReceiveEMSC[uctemp] << 8) |ucReceiveEMSC[uctemp +1];
4034 
4035             switch(usWriteBurstID)
4036             {
4037                 case MHL_BURST_ID_BLK_RCV_BUFFER_INFO:
4038                     usEMSCTxBufferSize = usEMSCTxBufferSize +((ucReceiveEMSC[uctemp +3] << 8) |ucReceiveEMSC[uctemp +2]) -MHL_EMSC_DATA_SIZE;
4039 
4040                     uctemp = uctemp +4;
4041 
4042                     MDRV_MHL_MSG_INFO("** MHL eMSC parsing buffer info in port %c !!\r\n", MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath));
4043 
4044                     break;
4045 
4046                 case MHL_BURST_ID_BITS_PER_PIXEL_FMT:
4047                     if(ucReceiveEMSC[uctemp +7] == MHL_VIEW_PIXEL_FORMATE_16BPP)
4048                     {
4049                         SET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_PP_MODE_FLAG);
4050                         CLR_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_24BIT_MODE_FLAG);
4051                     }
4052                     else if(ucReceiveEMSC[uctemp +7] == MHL_VIEW_PIXEL_FORMATE_24BPP)
4053                     {
4054                         SET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_24BIT_MODE_FLAG);
4055                         CLR_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_PP_MODE_FLAG);
4056                     }
4057 
4058                     uctemp = uctemp +8;
4059 
4060                     MDRV_MHL_MSG_INFO("** MHL eMSC parsing pexel FMT in port %c !!\r\n", MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath));
4061 
4062                     break;
4063 
4064                 case MHL_BURST_ID_EMSC_SUPPORT:
4065                     uctemp = uctemp +_mdrv_mhl_EMSCParsingEMSCSupport(pMHLResourcePrivate, &ucReceiveEMSC[uctemp +3]);
4066 
4067                     MDRV_MHL_MSG_INFO("** MHL eMSC parsing eMSC support in port %c !!\r\n", MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath));
4068 
4069                     break;
4070 
4071                 default:
4072                     MDRV_MHL_MSG_INFO("** MHL eMSC parsing unknow burst ID in port %c !!\r\n", MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath));
4073 
4074                     uctemp = ucReceiveEMSC[2] +3;
4075 
4076                     break;
4077             };
4078         }
4079     }
4080 
4081     pMHLResourcePrivate->usEMSCRxBufferSize = pMHLResourcePrivate->usEMSCRxBufferSize - ucReceiveEMSC[0];
4082     pMHLResourcePrivate->usEMSCTxBufferSize = usEMSCTxBufferSize + pMHLResourcePrivate->usEMSCTxBufferSize;
4083     usEMSCRxBufferSize = pMHLResourcePrivate->usEMSCRxBufferSize;
4084     usEMSCTxBufferSize = pMHLResourcePrivate->usEMSCTxBufferSize;
4085 
4086     MDRV_MHL_MSG_INFO("** MHL eMSC receive Rx buffer size %d in port %c !!\r\n", usEMSCRxBufferSize, MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath));
4087     MDRV_MHL_MSG_INFO("** MHL eMSC receive Tx buffer size %d in port %c !!\r\n", usEMSCTxBufferSize, MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath));
4088 }
4089 
4090 //**************************************************************************
4091 //  [Function Name]:
4092 //                  _mdrv_mhl_CbusRxHandler()
4093 //  [Description]
4094 //
4095 //  [Arguments]:
4096 //
4097 //  [Return]:
4098 //
4099 //**************************************************************************
_mdrv_mhl_CbusRxHandler(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate)4100 void _mdrv_mhl_CbusRxHandler(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate)
4101 {
4102     MS_U8 ucReceiveCount = 0;
4103     MS_U8 ucReceiveMSC[MHL_CBUS_DATA_SIZE +4];
4104 
4105     if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CBUS_CONNECT_FLAG))
4106     {
4107         // Check receive MSC
4108         if(mhal_mhl_CheckSRAMReceiveBuffer())
4109         {
4110             ucReceiveCount = pMHLResourcePrivate->ucReceiveCounter;
4111 
4112             if(ucReceiveCount > 0)
4113             {
4114                 for( ; ucReceiveCount > 0; ucReceiveCount--)
4115                 {
4116                     if(_mdrv_mhl_GetCbusReceiveMSC(ucReceiveMSC))
4117                     {
4118                         _mdrv_mhl_SetReceiveCaseFlag(pMHLResourcePrivate, ucReceiveMSC);
4119 
4120                         pMHLResourcePrivate->ucReceiveCounter--;
4121                     }
4122                 }
4123             }
4124             else if(!GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_RECEIVE_LOSE_FLAG))
4125             {
4126                 SET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_RECEIVE_LOSE_FLAG);
4127 
4128                 _mdrv_mhl_SetCbusTimerEvent(pMHLResourcePrivate, MHL_TIMER_EVENT_CHECK_RECEIVE_LOSE, MHL_CHECK_RECEIVE_LOSE_TIME);
4129             }
4130         }
4131 
4132         // Check receive EMSC
4133         if(pMHLResourcePrivate->ucEMSCReceiveCounter > 0)
4134         {
4135             _mdrv_mhl_ParsingEMSCReceiveData(pMHLResourcePrivate);
4136 
4137             pMHLResourcePrivate->ucEMSCReceiveCounter--;
4138         }
4139 
4140         if(pMHLResourcePrivate->ulCbusReceiveIndex > 0)
4141         {
4142             _mdrv_mhl_CbusReceiveEventProc(pMHLResourcePrivate);
4143 
4144             _mdrv_mhl_CbusMSGEventProc(pMHLResourcePrivate);
4145         }
4146     }
4147 }
4148 
4149 //**************************************************************************
4150 //  [Function Name]:
4151 //                  _mdrv_mhl_TxQueueHandler()
4152 //  [Description]
4153 //
4154 //  [Arguments]:
4155 //
4156 //  [Return]:
4157 //
4158 //**************************************************************************
_mdrv_mhl_TxQueueHandler(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate)4159 void _mdrv_mhl_TxQueueHandler(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate)
4160 {
4161     MS_U8 ucQueueIndex = 0;
4162 
4163     if(GET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_CBUS_SEND_FLAG))
4164     {
4165         ucQueueIndex = _mdrv_mhl_GetCbusQueueIndex(pMHLResourcePrivate);
4166 
4167         if(ucQueueIndex < MHL_CBUS_TOTAL_QUEUE_NUM)
4168         {
4169             if(_mdrv_mhl_CbusTxWriteCommand(pMHLResourcePrivate->stSignalStatusInfo.bECbusEnableFlag, &(pMHLResourcePrivate->stCbusQueueInfo[ucQueueIndex])))
4170             {
4171                 // Retry send packet twice
4172                 if(pMHLResourcePrivate->stCbusQueueInfo[ucQueueIndex].ucQueueState == MHL_QUEUE_STATE_SEND)
4173                 {
4174                     pMHLResourcePrivate->stCbusQueueInfo[ucQueueIndex].ucQueueState = MHL_QUEUE_STATE_IDLE;
4175                 }
4176                 else if(pMHLResourcePrivate->stCbusQueueInfo[ucQueueIndex].ucQueueState > MHL_QUEUE_STATE_SEND)
4177                 {
4178                     pMHLResourcePrivate->stCbusQueueInfo[ucQueueIndex].ucQueueState = MHL_QUEUE_STATE_SEND;
4179                 }
4180 
4181                 // Update current index to search index, but not Rx queue index
4182                 if(ucQueueIndex < MHL_CBUS_RX_QUEUE_INDEX)
4183                 {
4184                     pMHLResourcePrivate->ucCurrentQueueIndex = ucQueueIndex;
4185                 }
4186 
4187                 _mdrv_mhl_SetCbusTimerEvent(pMHLResourcePrivate, MHL_TIMER_EVENT_CBUS_SILENCE, MHL_CBUS_SEND_SILENCE_TIME);
4188 
4189                 CLR_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_CBUS_SEND_FLAG);
4190             }
4191         }
4192     }
4193 }
4194 
4195 //**************************************************************************
4196 //  [Function Name]:
4197 //                  _mdrv_mhl_SendDisplayCommand()
4198 //  [Description]
4199 //
4200 //  [Arguments]:
4201 //
4202 //  [Return]:
4203 //
4204 //**************************************************************************
_mdrv_mhl_SendDisplayCommand(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate)4205 void _mdrv_mhl_SendDisplayCommand(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate)
4206 {
4207     MS_U8 ucDisplayIndex = (pMHLResourcePrivate->usDisplayIndex) &BMASK(7:0);
4208     MS_U8 ucDisplayMask = MHL_CBUS_DISPLAY_MASK;
4209 
4210     if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_DISPLAY_COMMAND_ENABLE_FLAG))
4211     {
4212         if(_mdrv_mhl_CheckSendCommand(pMHLResourcePrivate))
4213         {
4214             if(GET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_ECBUS_FUNCTION_FLAG))
4215             {
4216                 ucDisplayMask = ucDisplayMask |MHL_ECBUS_DISPLAY_MASK;
4217             }
4218 
4219             ucDisplayIndex = ucDisplayIndex ^ucDisplayMask;
4220 
4221             if(ucDisplayIndex > 0)
4222             {
4223                 switch(_mdrv_mhl_CbusGetLeastFlag(ucDisplayIndex))
4224                 {
4225                     case MHL_CBUS_HPD_SET_FLAG:
4226                         _mdrv_mhl_CbusSendSetHPD(pMHLResourcePrivate, TRUE);
4227                         break;
4228 
4229                     case MHL_CBUS_DEVCAP_READY_FLAG:
4230                         _mdrv_mhl_CbusSendDevcapReady(pMHLResourcePrivate);
4231                         break;
4232 
4233                     case MHL_CBUS_PATH_EN_FLAG:
4234                         _mdrv_mhl_CbusSendPathEnable(pMHLResourcePrivate, TRUE);
4235                         break;
4236 
4237                     case MHL_CBUS_DEVCAP_CHANGE_FLAG:
4238                         _mdrv_mhl_CbusSendDevcapChange(pMHLResourcePrivate);
4239                         break;
4240 
4241                     case MHL_CBUS_VERSION_CODE_FLAG:
4242                         _mdrv_mhl_CbusSendVersionCode(pMHLResourcePrivate);
4243                         break;
4244 
4245                     case MHL_CBUS_LINK_STATUS_NORMAL_FLAG:
4246                         _mdrv_mhl_CbusSendLinkStatusNormal(pMHLResourcePrivate);
4247                         break;
4248 
4249                     default:
4250 
4251                         break;
4252                 };
4253             }
4254         }
4255         else if(GET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_CHECK_CONTENT_ON_FLAG))
4256         {
4257             if(!GET_MHL_DISPLAY_FLAG(pMHLResourcePrivate->usDisplayIndex, MHL_CBUS_HPD_SET_FLAG))
4258             {
4259                 _mdrv_mhl_CbusSendSetHPD(pMHLResourcePrivate, TRUE);
4260             }
4261             else if(GET_MHL_DISPLAY_FLAG(pMHLResourcePrivate->usDisplayIndex, MHL_CBUS_PATH_EN_FLAG))
4262             {
4263                 _mdrv_mhl_CbusSendPathEnable(pMHLResourcePrivate, FALSE);
4264             }
4265             else if(!GET_MHL_DISPLAY_FLAG(pMHLResourcePrivate->usDisplayIndex, MHL_CBUS_DEVCAP_READY_FLAG))
4266             {
4267                 _mdrv_mhl_CbusSendDevcapReady(pMHLResourcePrivate);
4268             }
4269         }
4270         else
4271         {
4272             if(GET_MHL_DISPLAY_FLAG(pMHLResourcePrivate->usDisplayIndex, MHL_CBUS_HPD_SET_FLAG))
4273             {
4274                 _mdrv_mhl_CbusSendSetHPD(pMHLResourcePrivate, FALSE);
4275 
4276                 CLR_MHL_DISPLAY_FLAG(pMHLResourcePrivate->usDisplayIndex, MHL_CBUS_PATH_EN_FLAG);
4277 
4278                 if(GET_MHL_DISPLAY_FLAG(pMHLResourcePrivate->usDisplayIndex, MHL_CBUS_LINK_STATUS_NORMAL_FLAG))
4279                 {
4280                     CLR_MHL_DISPLAY_FLAG(pMHLResourcePrivate->usDisplayIndex, MHL_CBUS_LINK_STATUS_NORMAL_FLAG);
4281                 }
4282             }
4283 
4284             if(GET_MHL_DEVICE_FLAG(pMHLResourcePrivate->usDeviceIndex, MHL_DEVICE_ROKU_DONGLE_FLAG))
4285             {
4286                 if(GET_MHL_DISPLAY_FLAG(pMHLResourcePrivate->usDisplayIndex, MHL_CBUS_DEVCAP_READY_FLAG))
4287                 {
4288                     _mdrv_mhl_CbusSendDevcapReady(pMHLResourcePrivate);
4289                 }
4290                 else if(GET_MHL_DISPLAY_FLAG(pMHLResourcePrivate->usDisplayIndex, MHL_CBUS_PATH_EN_FLAG))
4291                 {
4292                     _mdrv_mhl_CbusSendPathEnable(pMHLResourcePrivate, TRUE);
4293                 }
4294             }
4295 
4296             if(GET_MHL_DEVICE_FLAG(pMHLResourcePrivate->usDeviceIndex, MHL_DEVICE_PHONE_HTC_FLAG))
4297             {
4298                 if(GET_MHL_DISPLAY_FLAG(pMHLResourcePrivate->usDisplayIndex, MHL_CBUS_DEVCAP_READY_FLAG))
4299                 {
4300                     _mdrv_mhl_CbusSendDevcapReady(pMHLResourcePrivate);
4301                 }
4302             }
4303             else if(GET_MHL_DEVICE_FLAG(pMHLResourcePrivate->usDeviceIndex, MHL_DEVICE_PHONE_SONY_FLAG))
4304             {
4305                 if(GET_MHL_DISPLAY_FLAG(pMHLResourcePrivate->usDisplayIndex, MHL_CBUS_DEVCAP_READY_FLAG))
4306                 {
4307                     _mdrv_mhl_CbusSendDevcapReady(pMHLResourcePrivate);
4308                 }
4309             }
4310         }
4311     }
4312 }
4313 
4314 //**************************************************************************
4315 //  [Function Name]:
4316 //                  _mdrv_mhl_GetVenderIDProc()
4317 //  [Description]
4318 //
4319 //  [Arguments]:
4320 //
4321 //  [Return]:
4322 //
4323 //**************************************************************************
_mdrv_mhl_GetVenderIDProc(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate)4324 void _mdrv_mhl_GetVenderIDProc(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate)
4325 {
4326     if(GET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_GET_VENDER_ID_FLAG))
4327     {
4328         if(GET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_GET_VENDER_ID_FLAG))
4329         {
4330             if(GET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_ASK_FINISH_FLAG))
4331             {
4332                 CLR_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_ASK_FINISH_FLAG);
4333                 CLR_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_GET_VENDER_ID_FLAG);
4334                 CLR_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_GET_VENDER_ID_FLAG);
4335                 SET_MHL_DONE_FLAG(pMHLResourcePrivate->ucProcDoneIndex, MHL_GET_VENDER_ID_DONE_FLAG);
4336 
4337                 pMHLResourcePrivate->ucSourceVenderID = pMHLResourcePrivate->ucAskData;
4338 
4339 #if(MHL_DEBUG_SOURCE_INFO)
4340                 MDRV_MHL_MSG_INFO("** MHL get vender ID %d\r\n", pMHLResourcePrivate->ucSourceVenderID);
4341 #endif
4342             }
4343         }
4344         else if((!GET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_ASK_DATA_FLAG)) && (!GET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_ASK_FINISH_FLAG)))
4345         {
4346             if(_mdrv_mhl_CbusSendGetVenderID(pMHLResourcePrivate))
4347             {
4348                 SET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_GET_VENDER_ID_FLAG);
4349                 SET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_ASK_DATA_FLAG);
4350             }
4351         }
4352     }
4353 }
4354 
4355 //**************************************************************************
4356 //  [Function Name]:
4357 //                  _mdrv_mhl_CheckDeviceCapability()
4358 //  [Description]
4359 //
4360 //  [Arguments]:
4361 //
4362 //  [Return]:
4363 //
4364 //**************************************************************************
_mdrv_mhl_CheckDeviceCapability(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate)4365 void _mdrv_mhl_CheckDeviceCapability(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate)
4366 {
4367     MS_U16 usAdopterID = 0;
4368     MS_U16 usDeviceID = 0;
4369 
4370     usAdopterID = pMHLResourcePrivate->ucSourceDevcapTable[4] |(pMHLResourcePrivate->ucSourceDevcapTable[3] << 8);
4371     usDeviceID = pMHLResourcePrivate->ucSourceDevcapTable[12] |(pMHLResourcePrivate->ucSourceDevcapTable[11] << 8);
4372 
4373     pMHLResourcePrivate->usDeviceIndex = 0;
4374 
4375     if(usAdopterID == MHL_ADOPTER_ID_ROKU)
4376     {
4377         SET_MHL_DEVICE_FLAG(pMHLResourcePrivate->usDeviceIndex, MHL_DEVICE_ROKU_DONGLE_FLAG);
4378     }
4379 
4380     if(usAdopterID == MHL_ADOPTER_ID_HTC)
4381     {
4382         SET_MHL_DEVICE_FLAG(pMHLResourcePrivate->usDeviceIndex, MHL_DEVICE_PHONE_HTC_FLAG);
4383     }
4384 
4385     if(usAdopterID == MHL_ADOPTER_ID_SONY)
4386     {
4387         SET_MHL_DEVICE_FLAG(pMHLResourcePrivate->usDeviceIndex, MHL_DEVICE_PHONE_SONY_FLAG);
4388     }
4389 
4390     if(usDeviceID == MHL_DEVICE_ID_HTC)
4391     {
4392         // Do nothing
4393     }
4394 
4395     if(pMHLResourcePrivate->ucSourceDevcapTable[MHL_CBUS_FEATURE_FLAG] &BIT(0))
4396     {
4397         SET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_RCP_FUNCTION_FLAG);
4398     }
4399 
4400     if(pMHLResourcePrivate->ucSourceDevcapTable[MHL_CBUS_FEATURE_FLAG] &BIT(1))
4401     {
4402         SET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_RAP_FUNCTION_FLAG);
4403     }
4404 
4405     if(pMHLResourcePrivate->ucSourceDevcapTable[MHL_CBUS_VERSION] >= 0x30)
4406     {
4407         SET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_MHL3_VERSION_FLAG);
4408     }
4409 }
4410 
4411 //**************************************************************************
4412 //  [Function Name]:
4413 //                  _mdrv_mhl_ReadDeviceCapabilityProc()
4414 //  [Description]
4415 //
4416 //  [Arguments]:
4417 //
4418 //  [Return]:
4419 //
4420 //**************************************************************************
_mdrv_mhl_ReadDeviceCapabilityProc(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate)4421 void _mdrv_mhl_ReadDeviceCapabilityProc(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate)
4422 {
4423     MS_BOOL bReDoFlag = FALSE;
4424     MS_U8 ucBitNumber = 0;
4425 
4426     if(GET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_READ_DEVCAP_FLAG))
4427     {
4428         do
4429         {
4430             bReDoFlag = FALSE;
4431 
4432             if(pMHLResourcePrivate->usReadDevcapMask > 0)
4433             {
4434                 ucBitNumber = _mdrv_mhl_GetLeastBitNum(pMHLResourcePrivate->usReadDevcapMask);
4435 
4436                 if(GET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_READ_DEVCAP_FLAG))
4437                 {
4438                     if(GET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_ASK_FINISH_FLAG))
4439                     {
4440                         CLR_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_ASK_FINISH_FLAG);
4441                         CLR_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_READ_DEVCAP_FLAG);
4442 
4443                         pMHLResourcePrivate->ucSourceDevcapTable[ucBitNumber] = pMHLResourcePrivate->ucAskData;
4444 
4445 #if(MHL_DEBUG_SOURCE_INFO)
4446                         MDRV_MHL_MSG_INFO("** MHL read devcap[%d] = %x\r\n", ucBitNumber, pMHLResourcePrivate->ucSourceDevcapTable[ucBitNumber]);
4447 #endif
4448 
4449                         bReDoFlag = TRUE;
4450                     }
4451                 }
4452                 else if((!GET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_ASK_DATA_FLAG)) && (!GET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_ASK_FINISH_FLAG)))
4453                 {
4454                     if(_mdrv_mhl_CbusReadDeviceCapability(pMHLResourcePrivate, ucBitNumber, FALSE))
4455                     {
4456                         SET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_READ_DEVCAP_FLAG);
4457                         SET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_ASK_DATA_FLAG);
4458                     }
4459                 }
4460 
4461                 if(bReDoFlag)
4462                 {
4463                     pMHLResourcePrivate->usReadDevcapMask = MASKSET(pMHLResourcePrivate->usReadDevcapMask, 0, BIT(ucBitNumber));
4464 
4465                     if(pMHLResourcePrivate->usReadDevcapMask == 0)
4466                     {
4467                         SET_MHL_DONE_FLAG(pMHLResourcePrivate->ucProcDoneIndex, MHL_READ_DEVCAP_DONE_FLAG);
4468 
4469                         _mdrv_mhl_CheckDeviceCapability(pMHLResourcePrivate);
4470                     }
4471                 }
4472             }
4473             else
4474             {
4475                 CLR_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_READ_DEVCAP_FLAG);
4476             }
4477         }while(bReDoFlag);
4478 
4479         if(GET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_DEVCAP_FLAG))
4480         {
4481             CLR_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_DEVCAP_FLAG);
4482         }
4483     }
4484     else
4485     {
4486         if(GET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_DEVCAP_FLAG))
4487         {
4488             if(!GET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_READ_XDEVCAP_FLAG))
4489             {
4490                 CLR_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_DEVCAP_FLAG);
4491                 SET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_READ_DEVCAP_FLAG);
4492             }
4493         }
4494     }
4495 }
4496 
4497 //**************************************************************************
4498 //  [Function Name]:
4499 //                  _mdrv_mhl_ReadExtendDeviceCapabilityProc()
4500 //  [Description]
4501 //
4502 //  [Arguments]:
4503 //
4504 //  [Return]:
4505 //
4506 //**************************************************************************
_mdrv_mhl_ReadExtendDeviceCapabilityProc(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate)4507 void _mdrv_mhl_ReadExtendDeviceCapabilityProc(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate)
4508 {
4509     MS_BOOL bReDoFlag = FALSE;
4510     MS_U8 ucBitNumber = 0;
4511 
4512     if(GET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_READ_XDEVCAP_FLAG))
4513     {
4514         do
4515         {
4516             bReDoFlag = FALSE;
4517 
4518             if(pMHLResourcePrivate->usReadExtendDevcapMask > 0)
4519             {
4520                 ucBitNumber = _mdrv_mhl_GetLeastBitNum(pMHLResourcePrivate->usReadExtendDevcapMask);
4521 
4522                 if(GET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_READ_DEVCAP_FLAG))
4523                 {
4524                     if(GET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_ASK_FINISH_FLAG))
4525                     {
4526                         CLR_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_ASK_FINISH_FLAG);
4527                         CLR_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_READ_DEVCAP_FLAG);
4528 
4529                         pMHLResourcePrivate->ucSourceDevcapTable[MHL_DEVICE_CAPABILITY_SIZE +ucBitNumber] = pMHLResourcePrivate->ucAskData;
4530 
4531 #if(MHL_DEBUG_SOURCE_INFO)
4532                         MDRV_MHL_MSG_INFO("** MHL read extend devcap[%d] = %x\r\n", ucBitNumber, pMHLResourcePrivate->ucSourceDevcapTable[MHL_DEVICE_CAPABILITY_SIZE +ucBitNumber]);
4533 #endif
4534 
4535                         bReDoFlag = TRUE;
4536                     }
4537                 }
4538                 else if((!GET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_ASK_DATA_FLAG)) && (!GET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_ASK_FINISH_FLAG)))
4539                 {
4540                     if(_mdrv_mhl_CbusReadDeviceCapability(pMHLResourcePrivate, ucBitNumber, TRUE))
4541                     {
4542                         SET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_READ_DEVCAP_FLAG);
4543                         SET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_ASK_DATA_FLAG);
4544                     }
4545                 }
4546 
4547                 if(bReDoFlag)
4548                 {
4549                     pMHLResourcePrivate->usReadExtendDevcapMask = MASKSET(pMHLResourcePrivate->usReadExtendDevcapMask, 0, BIT(ucBitNumber));
4550 
4551                     if(pMHLResourcePrivate->usReadExtendDevcapMask == 0)
4552                     {
4553                         SET_MHL_DONE_FLAG(pMHLResourcePrivate->ucProcDoneIndex, MHL_READ_XDEVCAP_DONE_FLAG);
4554 
4555                         _mdrv_mhl_CheckDeviceCapability(pMHLResourcePrivate);
4556                     }
4557                 }
4558             }
4559             else
4560             {
4561                 CLR_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_READ_XDEVCAP_FLAG);
4562             }
4563         }while(bReDoFlag);
4564 
4565         if(GET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_XDEVCAP_SUPPORT_FLAG))
4566         {
4567             CLR_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_XDEVCAP_SUPPORT_FLAG);
4568         }
4569     }
4570     else
4571     {
4572         if(GET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_XDEVCAP_SUPPORT_FLAG))
4573         {
4574             if(!GET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_READ_DEVCAP_FLAG))
4575             {
4576                 CLR_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_XDEVCAP_SUPPORT_FLAG);
4577                 SET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_READ_XDEVCAP_FLAG);
4578             }
4579         }
4580     }
4581 }
4582 
4583 //**************************************************************************
4584 //  [Function Name]:
4585 //                  _mdrv_mhl_WriteBurstEventProc()
4586 //  [Description]
4587 //
4588 //  [Arguments]:
4589 //
4590 //  [Return]:
4591 //
4592 //**************************************************************************
_mdrv_mhl_WriteBurstEventProc(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate)4593 void _mdrv_mhl_WriteBurstEventProc(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate)
4594 {
4595     switch(pMHLResourcePrivate->ucWriteBurstState)
4596     {
4597         case MHL_CBUS_WRITE_BURST_START:
4598             if(_mdrv_mhl_CbusWriteStatusOrSetInt(pMHLResourcePrivate, 0x20, BIT(2), FALSE))
4599             {
4600                 pMHLResourcePrivate->ucWriteBurstState = MHL_CBUS_WRITE_BURST_SEND_REQUEST;
4601 
4602                 _mdrv_mhl_SetCbusTimerEvent(pMHLResourcePrivate, MHL_TIMER_EVENT_WAIT_WRITE_GRANT, MHL_WAIT_WRITE_GRANT_TIME);
4603             }
4604 
4605             break;
4606 
4607         case MHL_CBUS_WRITE_BURST_SEND_DATA:
4608             if(_mdrv_mhl_CbusWriteStatusOrSetInt(pMHLResourcePrivate, 0x20, BIT(1), FALSE))
4609             {
4610                 pMHLResourcePrivate->ucWriteBurstState = MHL_CBUS_WRITE_BURST_END;
4611             }
4612             break;
4613 
4614         case MHL_CBUS_WRITE_BURST_END:
4615             pMHLResourcePrivate->ucWriteBurstState = MHL_CBUS_WRITE_BURST_NONE;
4616             break;
4617 
4618         default:
4619 
4620             break;
4621     };
4622 }
4623 
4624 //**************************************************************************
4625 //  [Function Name]:
4626 //                  _mdrv_mhl_GetDTDBurstfor3D()
4627 //  [Description]
4628 //
4629 //  [Arguments]:
4630 //
4631 //  [Return]:
4632 //
4633 //**************************************************************************
_mdrv_mhl_GetDTDBurstfor3D(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate,MS_U8 * pData)4634 MS_BOOL _mdrv_mhl_GetDTDBurstfor3D(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate, MS_U8 *pData)
4635 {
4636     MS_BOOL bFinish = FALSE;
4637     MS_U8 uctemp = 0;
4638     MS_U8 ucDTDCount = 0;
4639     MS_U8 ucSequence = pMHLResourcePrivate->ucWriteBurstSequence;
4640 
4641     ucDTDCount = ucSequence *MHL_3D_SEQUENCE_LENGTH;
4642 
4643     pData[0] = (MHL_BURST_ID_3D_DTD >> 8);
4644     pData[1] = (MHL_BURST_ID_3D_DTD &BMASK(7:0));
4645     pData[3] = pMHLResourcePrivate->uc3DTotalEntryDTD;
4646 
4647     if(pMHLResourcePrivate->uc3DTotalEntryDTD == 0)
4648     {
4649         bFinish = TRUE;
4650     }
4651 
4652     for(uctemp = 0; uctemp < MHL_3D_SEQUENCE_LENGTH; uctemp++)
4653     {
4654         if((!bFinish) && ((ucDTDCount +uctemp) == (pMHLResourcePrivate->uc3DTotalEntryDTD -1)))
4655         {
4656             bFinish = TRUE;
4657         }
4658 
4659         if((ucDTDCount +uctemp) < pMHLResourcePrivate->uc3DTotalEntryDTD)
4660         {
4661             pData[6 +uctemp *MHL_3D_ITEM_LENGTH] = 0;
4662             pData[6 +uctemp *MHL_3D_ITEM_LENGTH +1] = pMHLResourcePrivate->uc3DInformationDTD[ucDTDCount +uctemp] &BMASK(3:0);
4663         }
4664         else
4665         {
4666             pData[6 +uctemp *MHL_3D_ITEM_LENGTH] = 0;
4667             pData[6 +uctemp *MHL_3D_ITEM_LENGTH +1] = 0;
4668         }
4669     }
4670 
4671     ucSequence++;
4672 
4673     pData[4] = ucSequence;
4674 
4675     if(bFinish)
4676     {
4677         pData[5] = pMHLResourcePrivate->uc3DTotalEntryDTD -ucDTDCount;
4678         ucSequence = 0;
4679     }
4680     else
4681     {
4682         pData[5] = MHL_3D_SEQUENCE_LENGTH;
4683     }
4684 
4685     pData[2] = _mdrv_mhl_WriteBurstCheckSum(pData);
4686 
4687     pMHLResourcePrivate->ucWriteBurstSequence = ucSequence;
4688 
4689     return bFinish;
4690 }
4691 
4692 //**************************************************************************
4693 //  [Function Name]:
4694 //                  _mdrv_mhl_GetVICBurstfor3D()
4695 //  [Description]
4696 //
4697 //  [Arguments]:
4698 //
4699 //  [Return]:
4700 //
4701 //**************************************************************************
_mdrv_mhl_GetVICBurstfor3D(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate,MS_U8 * pData)4702 MS_BOOL _mdrv_mhl_GetVICBurstfor3D(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate, MS_U8 *pData)
4703 {
4704     MS_BOOL bFinish = FALSE;
4705     MS_U8 uctemp = 0;
4706     MS_U8 ucVICCount = 0;
4707     MS_U8 ucSequence = pMHLResourcePrivate->ucWriteBurstSequence;
4708 
4709     ucVICCount = ucSequence *MHL_3D_SEQUENCE_LENGTH;
4710 
4711     pData[0] = (MHL_BURST_ID_3D_VIC >> 8);
4712     pData[1] = (MHL_BURST_ID_3D_VIC &BMASK(7:0));
4713     pData[3] = pMHLResourcePrivate->uc3DTotalEntryVIC;
4714 
4715     if(pMHLResourcePrivate->uc3DTotalEntryVIC == 0)
4716     {
4717         bFinish = TRUE;
4718     }
4719 
4720     for(uctemp = 0; uctemp < MHL_3D_SEQUENCE_LENGTH; uctemp++)
4721     {
4722         if((!bFinish) && ((ucVICCount +uctemp) == (pMHLResourcePrivate->uc3DTotalEntryVIC -1)))
4723         {
4724             bFinish = TRUE;
4725         }
4726 
4727         if((ucVICCount +uctemp) < pMHLResourcePrivate->uc3DTotalEntryVIC)
4728         {
4729             pData[6 +uctemp *MHL_3D_ITEM_LENGTH] = 0;
4730             pData[6 +uctemp *MHL_3D_ITEM_LENGTH +1] = pMHLResourcePrivate->uc3DInformationVIC[ucVICCount +uctemp] &BMASK(3:0);
4731         }
4732         else
4733         {
4734             pData[6 +uctemp *MHL_3D_ITEM_LENGTH] = 0;
4735             pData[6 +uctemp *MHL_3D_ITEM_LENGTH +1] = 0;
4736         }
4737     }
4738 
4739     ucSequence++;
4740 
4741     pData[4] = ucSequence;
4742 
4743     if(bFinish)
4744     {
4745         pData[5] = pMHLResourcePrivate->uc3DTotalEntryVIC -ucVICCount;
4746         ucSequence = 0;
4747     }
4748     else
4749     {
4750         pData[5] = MHL_3D_SEQUENCE_LENGTH;
4751     }
4752 
4753     pData[2] = _mdrv_mhl_WriteBurstCheckSum(pData);
4754 
4755     pMHLResourcePrivate->ucWriteBurstSequence = ucSequence;
4756 
4757     return bFinish;
4758 }
4759 
4760 //**************************************************************************
4761 //  [Function Name]:
4762 //                  _mdrv_mhl_Send3DTimingInformation()
4763 //  [Description]
4764 //
4765 //  [Arguments]:
4766 //
4767 //  [Return]:
4768 //
4769 //**************************************************************************
_mdrv_mhl_Send3DTimingInformation(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate)4770 void _mdrv_mhl_Send3DTimingInformation(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate)
4771 {
4772     MS_BOOL bFinish = FALSE;
4773     MS_U8 ucData[MHL_MSC_SCRATCHPAD_SIZE] = {0};
4774 
4775     if(GET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_3D_DTD_FLAG))
4776     {
4777         if(_mdrv_mhl_GetDTDBurstfor3D(pMHLResourcePrivate, ucData))
4778         {
4779             bFinish = TRUE;
4780         }
4781 
4782         if(_mdrv_mhl_CbusSendWriteBurst(pMHLResourcePrivate, 0x40, MHL_MSC_SCRATCHPAD_SIZE, ucData))
4783         {
4784             if(bFinish)
4785             {
4786                 CLR_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_3D_DTD_FLAG);
4787             }
4788 
4789             pMHLResourcePrivate->ucWriteBurstState = MHL_CBUS_WRITE_BURST_SEND_DATA;
4790 
4791             MDRV_MHL_MSG_INFO("** MHL sent 3D DTD port %c in %d\r\n", MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath), ucData[4]);
4792         }
4793     }
4794     else if(GET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_3D_VIC_FLAG))
4795     {
4796         if(_mdrv_mhl_GetVICBurstfor3D(pMHLResourcePrivate, ucData))
4797         {
4798             bFinish= TRUE;
4799         }
4800 
4801         if(_mdrv_mhl_CbusSendWriteBurst(pMHLResourcePrivate, 0x40, MHL_MSC_SCRATCHPAD_SIZE, ucData))
4802         {
4803             if(bFinish)
4804             {
4805                 CLR_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_3D_VIC_FLAG);
4806                 CLR_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_3D_INFORMATION_FLAG);
4807             }
4808 
4809             pMHLResourcePrivate->ucWriteBurstState = MHL_CBUS_WRITE_BURST_SEND_DATA;
4810 
4811             MDRV_MHL_MSG_INFO("** MHL sent 3D VIC port %c in %d\r\n", MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath), ucData[4]);
4812         }
4813     }
4814 }
4815 
4816 //**************************************************************************
4817 //  [Function Name]:
4818 //                  _mdrv_mhl_GetBurstforVirtualChannel()
4819 //  [Description]
4820 //
4821 //  [Arguments]:
4822 //
4823 //  [Return]:
4824 //
4825 //**************************************************************************
_mdrv_mhl_GetBurstforVirtualChannel(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate,MS_BOOL bVCConfirm,MS_U8 * pData)4826 MS_BOOL _mdrv_mhl_GetBurstforVirtualChannel(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate, MS_BOOL bVCConfirm, MS_U8 *pData)
4827 {
4828     MS_BOOL bFinish = FALSE;
4829     MS_U8 uctemp = 0;
4830     MS_U8 ucVCCount = 0;
4831     MS_U8 ucSequence = pMHLResourcePrivate->ucWriteBurstSequence;
4832     MS_U8 ucVCTotalEntry = 0;
4833     MS_U8 ucVCFinishEntry = 0;
4834     MS_U16 usWriteBurstID = MHL_BURST_ID_VC_ASSIGN;
4835 
4836     if(bVCConfirm)
4837     {
4838         usWriteBurstID = MHL_BURST_ID_VC_CONFIRM;
4839     }
4840 
4841     ucVCFinishEntry = ucSequence *MHL_VC_SEQUENCE_LENGTH;
4842 
4843     pData[0] = (usWriteBurstID >> 8);
4844     pData[1] = (usWriteBurstID &BMASK(7:0));
4845     pData[15] = 0;
4846 
4847     for(uctemp = 0; uctemp < MHL_VIRTUAL_CHANNEL_LENGTH; uctemp++)
4848     {
4849         if(pMHLResourcePrivate->stVirtualChannelInfo[uctemp].bVCConfirm)
4850         {
4851             ucVCTotalEntry++;
4852 
4853             if(ucVCFinishEntry > 0)
4854             {
4855                 ucVCFinishEntry--;
4856             }
4857             else if(ucVCCount < MHL_VC_SEQUENCE_LENGTH)
4858             {
4859                 pData[6 +ucVCCount *MHL_VC_ITEM_LENGTH] = pMHLResourcePrivate->stVirtualChannelInfo[uctemp].ucVCNumber;
4860                 pData[6 +ucVCCount *MHL_VC_ITEM_LENGTH +1] = pMHLResourcePrivate->stVirtualChannelInfo[uctemp].ucVCFeatureID;
4861 
4862                 if(bVCConfirm)
4863                 {
4864                     pData[6 +ucVCCount *MHL_VC_ITEM_LENGTH +2] = pMHLResourcePrivate->stVirtualChannelInfo[uctemp].ucVCResponseCode;
4865                 }
4866                 else
4867                 {
4868                     pData[6 +ucVCCount *MHL_VC_ITEM_LENGTH +2] = pMHLResourcePrivate->stVirtualChannelInfo[uctemp].ucVCSlotSize;
4869                 }
4870 
4871                 ucVCCount++;
4872             }
4873         }
4874     }
4875 
4876     ucSequence++;
4877 
4878     pData[3] = ucVCTotalEntry;
4879     pData[4] = ucSequence;
4880     pData[5] = ucVCCount;
4881     pData[2] = _mdrv_mhl_WriteBurstCheckSum(pData);
4882 
4883     if(((ucSequence -1) *MHL_VC_SEQUENCE_LENGTH +ucVCCount) == ucVCTotalEntry)
4884     {
4885         bFinish = TRUE;
4886         ucSequence = 0;
4887     }
4888 
4889     pMHLResourcePrivate->ucWriteBurstSequence = ucSequence;
4890 
4891     return bFinish;
4892 }
4893 
4894 //**************************************************************************
4895 //  [Function Name]:
4896 //                  _mdrv_mhl_SendVirtualChannelInformation()
4897 //  [Description]
4898 //
4899 //  [Arguments]:
4900 //
4901 //  [Return]:
4902 //
4903 //**************************************************************************
_mdrv_mhl_SendVirtualChannelInformation(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate)4904 void _mdrv_mhl_SendVirtualChannelInformation(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate)
4905 {
4906     MS_BOOL bFinish = FALSE;
4907     MS_BOOL bSendVCConfirm = FALSE;
4908     MS_U8 ucData[MHL_MSC_SCRATCHPAD_SIZE] = {0};
4909 
4910     if(_mdrv_mhl_GetBurstforVirtualChannel(pMHLResourcePrivate, GET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_VC_CONFIRM_FLAG), ucData))
4911     {
4912         bFinish = TRUE;
4913     }
4914 
4915     if(_mdrv_mhl_CbusSendWriteBurst(pMHLResourcePrivate, 0x40, MHL_MSC_SCRATCHPAD_SIZE, ucData))
4916     {
4917         if(bFinish)
4918         {
4919             if(GET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_VC_CONFIRM_FLAG))
4920             {
4921                 CLR_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_VC_CONFIRM_FLAG);
4922 
4923                 bSendVCConfirm = TRUE;
4924             }
4925 
4926             CLR_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_VC_INFORMATION_FLAG);
4927         }
4928 
4929         pMHLResourcePrivate->ucWriteBurstState = MHL_CBUS_WRITE_BURST_SEND_DATA;
4930 
4931         MDRV_MHL_MSG_INFO("** MHL sent VC information port %c in %d\r\n", MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath), ucData[4]);
4932     }
4933 
4934     if(bSendVCConfirm)
4935     {
4936         _mdrv_mhl_SortingVCInformation(pMHLResourcePrivate, TRUE);
4937 
4938         _mdrv_mhl_eCbusTimeSlotAllocation(pMHLResourcePrivate);
4939     }
4940 }
4941 
4942 //**************************************************************************
4943 //  [Function Name]:
4944 //                  mdrv_mhl_GetHighEndVideoVIC()
4945 //  [Description]
4946 //
4947 //  [Arguments]:
4948 //
4949 //  [Return]:
4950 //
4951 //**************************************************************************
_mdrv_mhl_GetHighEndVideoVIC(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate,MS_U8 * pData)4952 MS_BOOL _mdrv_mhl_GetHighEndVideoVIC(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate, MS_U8 *pData)
4953 {
4954     MS_BOOL bFinish = FALSE;
4955     MS_U8 uctemp = 0;
4956     MS_U8 ucEntryCount = 0;
4957     MS_U8 ucSequence = pMHLResourcePrivate->ucWriteBurstSequence;
4958     MS_U8 ucFinishEntry = 0;
4959     MS_U8 ucTotalEntry = pMHLResourcePrivate->ucHighEndVICTotalEntry;
4960 
4961     ucFinishEntry = ucSequence *MHL_HEV_VIC_SEQUENCE_LENGTH;
4962 
4963     pData[0] = (MHL_BURST_ID_HEV_VIC >> 8);
4964     pData[1] = (MHL_BURST_ID_HEV_VIC &BMASK(7:0));
4965     pData[3] = ucTotalEntry;
4966 
4967     for(uctemp = 0; uctemp < MHL_HEV_VIC_SEQUENCE_LENGTH; uctemp++)
4968     {
4969         if((uctemp +ucFinishEntry) == ucTotalEntry)
4970         {
4971             break;
4972         }
4973 
4974         pData[6 +(uctemp *2)] = pMHLResourcePrivate->usHighEndVICTable[uctemp +ucFinishEntry] >> 8;
4975         pData[7 +(uctemp *2)] = pMHLResourcePrivate->usHighEndVICTable[uctemp +ucFinishEntry] &BMASK(7:0);
4976 
4977         ucEntryCount++;
4978     }
4979 
4980     ucSequence++;
4981 
4982     pData[4] = ucSequence;
4983     pData[5] = ucEntryCount;
4984     pData[2] = _mdrv_mhl_WriteBurstCheckSum(pData);
4985 
4986     if(((ucSequence -1) *MHL_HEV_VIC_SEQUENCE_LENGTH +ucEntryCount) == ucTotalEntry)
4987     {
4988         bFinish = TRUE;
4989         ucSequence = 0;
4990     }
4991 
4992     pMHLResourcePrivate->ucWriteBurstSequence = ucSequence;
4993 
4994     return bFinish;
4995 }
4996 
4997 //**************************************************************************
4998 //  [Function Name]:
4999 //                  _mdrv_mhl_GetHighEndVideoDTDA()
5000 //  [Description]
5001 //
5002 //  [Arguments]:
5003 //
5004 //  [Return]:
5005 //
5006 //**************************************************************************
_mdrv_mhl_GetHighEndVideoDTDA(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate,MS_U8 * pData)5007 MS_BOOL _mdrv_mhl_GetHighEndVideoDTDA(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate, MS_U8 *pData)
5008 {
5009     MS_BOOL bFinish = FALSE;
5010     MS_U8 uctemp = 0;
5011     MS_U8 ucEntryCount = 0;
5012     MS_U8 ucSequence = pMHLResourcePrivate->ucWriteBurstSequence;
5013     MS_U8 ucFinishEntry = 0;
5014     MS_U8 ucTotalEntry = MHL_HEV_DTD_TOTAL_ENTRY;
5015 
5016     ucFinishEntry = ucSequence *MHL_HEV_DTD_SEQUENCE_LENGTH;
5017 
5018     pData[0] = (MHL_BURST_ID_HEV_DTDA >> 8);
5019     pData[1] = (MHL_BURST_ID_HEV_DTDA &BMASK(7:0));
5020     pData[3] = MHL_HEV_DTD_TOTAL_ENTRY;
5021 
5022     for(uctemp = 0; uctemp < ucTotalEntry; uctemp++)
5023     {
5024         if(ucFinishEntry > 0)
5025         {
5026             ucFinishEntry--;
5027         }
5028         else if(ucEntryCount < MHL_HEV_DTD_SEQUENCE_LENGTH)
5029         {
5030             ucEntryCount++;
5031         }
5032     }
5033 
5034     ucSequence++;
5035 
5036     pData[4] = ucSequence;
5037     pData[2] = _mdrv_mhl_WriteBurstCheckSum(pData);
5038 
5039     if(((ucSequence -1) *MHL_HEV_DTD_SEQUENCE_LENGTH +ucEntryCount) == MHL_HEV_DTD_TOTAL_ENTRY)
5040     {
5041         bFinish = TRUE;
5042         ucSequence = 0;
5043     }
5044 
5045     pMHLResourcePrivate->ucWriteBurstSequence = ucSequence;
5046 
5047     return bFinish;
5048 }
5049 
5050 //**************************************************************************
5051 //  [Function Name]:
5052 //                  _mdrv_mhl_GetHighEndVideoDTDB()
5053 //  [Description]
5054 //
5055 //  [Arguments]:
5056 //
5057 //  [Return]:
5058 //
5059 //**************************************************************************
_mdrv_mhl_GetHighEndVideoDTDB(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate,MS_U8 * pData)5060 MS_BOOL _mdrv_mhl_GetHighEndVideoDTDB(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate, MS_U8 *pData)
5061 {
5062     MS_BOOL bFinish = FALSE;
5063     MS_U8 uctemp = 0;
5064     MS_U8 ucEntryCount = 0;
5065     MS_U8 ucSequence = pMHLResourcePrivate->ucWriteBurstSequence;
5066     MS_U8 ucFinishEntry = 0;
5067     MS_U8 ucTotalEntry = MHL_HEV_DTD_TOTAL_ENTRY;
5068 
5069     ucFinishEntry = ucSequence *MHL_HEV_DTD_SEQUENCE_LENGTH;
5070 
5071     pData[0] = (MHL_BURST_ID_HEV_DTDB >> 8);
5072     pData[1] = (MHL_BURST_ID_HEV_DTDB &BMASK(7:0));
5073     pData[3] = MHL_HEV_DTD_TOTAL_ENTRY;
5074 
5075     for(uctemp = 0; uctemp < ucTotalEntry; uctemp++)
5076     {
5077         if(ucFinishEntry > 0)
5078         {
5079             ucFinishEntry--;
5080         }
5081         else if(ucEntryCount < MHL_HEV_DTD_SEQUENCE_LENGTH)
5082         {
5083             ucEntryCount++;
5084         }
5085     }
5086 
5087     ucSequence++;
5088 
5089     pData[4] = ucSequence;
5090     pData[2] = _mdrv_mhl_WriteBurstCheckSum(pData);
5091 
5092     if(((ucSequence -1) *MHL_HEV_DTD_SEQUENCE_LENGTH +ucEntryCount) == MHL_HEV_DTD_TOTAL_ENTRY)
5093     {
5094         bFinish = TRUE;
5095         ucSequence = 0;
5096     }
5097 
5098     pMHLResourcePrivate->ucWriteBurstSequence = ucSequence;
5099 
5100     return bFinish;
5101 }
5102 
5103 //**************************************************************************
5104 //  [Function Name]:
5105 //                  _mdrv_mhl_SendHighEndVideoSupport()
5106 //  [Description]
5107 //
5108 //  [Arguments]:
5109 //
5110 //  [Return]:
5111 //
5112 //**************************************************************************
_mdrv_mhl_SendHighEndVideoSupport(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate)5113 void _mdrv_mhl_SendHighEndVideoSupport(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate)
5114 {
5115     MS_BOOL bFinish = FALSE;
5116     MS_U8 ucData[MHL_MSC_SCRATCHPAD_SIZE] = {0};
5117 
5118     if(GET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_HEV_VIC_FLAG))
5119     {
5120         if(_mdrv_mhl_GetHighEndVideoVIC(pMHLResourcePrivate, ucData))
5121         {
5122             bFinish = TRUE;
5123         }
5124 
5125         if(_mdrv_mhl_CbusSendWriteBurst(pMHLResourcePrivate, 0x40, MHL_MSC_SCRATCHPAD_SIZE, ucData))
5126         {
5127             if(bFinish)
5128             {
5129                 CLR_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_HEV_VIC_FLAG);
5130             }
5131 
5132             pMHLResourcePrivate->ucWriteBurstState = MHL_CBUS_WRITE_BURST_SEND_DATA;
5133 
5134             MDRV_MHL_MSG_INFO("** MHL sent HEV VIC port %c in %d\r\n", MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath), ucData[4]);
5135         }
5136     }
5137     else if(GET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_HEV_DTDA_FLAG))
5138     {
5139         if(_mdrv_mhl_GetHighEndVideoDTDA(pMHLResourcePrivate, ucData))
5140         {
5141             bFinish = TRUE;
5142         }
5143 
5144         if(_mdrv_mhl_CbusSendWriteBurst(pMHLResourcePrivate, 0x40, MHL_MSC_SCRATCHPAD_SIZE, ucData))
5145         {
5146             if(bFinish)
5147             {
5148                 CLR_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_HEV_DTDA_FLAG);
5149             }
5150 
5151             pMHLResourcePrivate->ucWriteBurstState = MHL_CBUS_WRITE_BURST_SEND_DATA;
5152 
5153             MDRV_MHL_MSG_INFO("** MHL sent HEV DTDA port %c in %d\r\n", MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath), ucData[4]);
5154         }
5155     }
5156     else if(GET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_HEV_DTDB_FLAG))
5157     {
5158         if(_mdrv_mhl_GetHighEndVideoDTDB(pMHLResourcePrivate, ucData))
5159         {
5160             bFinish = TRUE;
5161         }
5162 
5163         if(_mdrv_mhl_CbusSendWriteBurst(pMHLResourcePrivate, 0x40, MHL_MSC_SCRATCHPAD_SIZE, ucData))
5164         {
5165             if(bFinish)
5166             {
5167                 CLR_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_HEV_DTDB_FLAG);
5168                 CLR_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_HIGH_END_VIDEO_FLAG);
5169             }
5170 
5171             pMHLResourcePrivate->ucWriteBurstState = MHL_CBUS_WRITE_BURST_SEND_DATA;
5172 
5173             MDRV_MHL_MSG_INFO("** MHL sent HEV DTDB port %c in %d\r\n", MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath), ucData[4]);
5174         }
5175     }
5176 }
5177 
5178 //**************************************************************************
5179 //  [Function Name]:
5180 //                  mdrv_mhl_GetAudioDataTunnel()
5181 //  [Description]
5182 //
5183 //  [Arguments]:
5184 //
5185 //  [Return]:
5186 //
5187 //**************************************************************************
_mdrv_mhl_GetAudioDataTunnel(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate,MS_U8 * pData)5188 MS_BOOL _mdrv_mhl_GetAudioDataTunnel(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate, MS_U8 *pData)
5189 {
5190     MS_BOOL bFinish = FALSE;
5191     MS_U8 uctemp = 0;
5192     MS_U8 ucEntryCount = 0;
5193     MS_U8 ucSequence = pMHLResourcePrivate->ucWriteBurstSequence;
5194     MS_U8 ucFinishEntry = 0;
5195     MS_U8 ucTotalEntry = MHL_AUDIO_TUNNEL_TOTAL_ENTRY;
5196 
5197     ucFinishEntry = ucSequence *MHL_AUDIO_TUNNEL_SEQUENCE_LENGTH;
5198 
5199     pData[0] = (MHL_BURST_ID_ADT_BURSTID >> 8);
5200     pData[1] = (MHL_BURST_ID_ADT_BURSTID &BMASK(7:0));
5201     pData[3] = ucTotalEntry;
5202 
5203     if((ucSequence == 0) && (MHL_AUDIO_TUNNEL_SADB_RNTRY > 0)) // Support speaker allocation data block
5204     {
5205         pData[5] = 1;
5206     }
5207 
5208     for(uctemp = 0; uctemp < MHL_AUDIO_TUNNEL_SEQUENCE_LENGTH; uctemp++)
5209     {
5210         if((uctemp +ucFinishEntry) == ucTotalEntry)
5211         {
5212             break;
5213         }
5214 
5215         pData[7 +(uctemp *3)] = pMHLResourcePrivate->ulAudioTunnelTable[uctemp +ucFinishEntry] >> 16;
5216         pData[8 +(uctemp *3)] = pMHLResourcePrivate->ulAudioTunnelTable[uctemp +ucFinishEntry] >> 8;
5217         pData[9 +(uctemp *3)] = pMHLResourcePrivate->ulAudioTunnelTable[uctemp +ucFinishEntry] &BMASK(7:0);
5218 
5219         ucEntryCount++;
5220     }
5221 
5222     ucSequence++;
5223 
5224     pData[4] = ucSequence;
5225     pData[6] = ucEntryCount;
5226     pData[2] = _mdrv_mhl_WriteBurstCheckSum(pData);
5227 
5228     if(((ucSequence -1) *MHL_AUDIO_TUNNEL_SEQUENCE_LENGTH +ucEntryCount) == ucTotalEntry)
5229     {
5230         bFinish = TRUE;
5231         ucSequence = 0;
5232     }
5233 
5234     pMHLResourcePrivate->ucWriteBurstSequence = ucSequence;
5235 
5236     return bFinish;
5237 }
5238 
5239 //**************************************************************************
5240 //  [Function Name]:
5241 //                  _mdrv_mhl_SendAudioDataTunnelSupport()
5242 //  [Description]
5243 //
5244 //  [Arguments]:
5245 //
5246 //  [Return]:
5247 //
5248 //**************************************************************************
_mdrv_mhl_SendAudioDataTunnelSupport(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate)5249 void _mdrv_mhl_SendAudioDataTunnelSupport(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate)
5250 {
5251     MS_BOOL bFinish = FALSE;
5252     MS_U8 ucData[MHL_MSC_SCRATCHPAD_SIZE] = {0};
5253 
5254     if(_mdrv_mhl_GetAudioDataTunnel(pMHLResourcePrivate, ucData))
5255     {
5256         bFinish = TRUE;
5257     }
5258 
5259     if(_mdrv_mhl_CbusSendWriteBurst(pMHLResourcePrivate, 0x40, MHL_MSC_SCRATCHPAD_SIZE, ucData))
5260     {
5261         if(bFinish)
5262         {
5263             CLR_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_AUDIO_DATA_TUNNEL_FLAG);
5264         }
5265 
5266         pMHLResourcePrivate->ucWriteBurstState = MHL_CBUS_WRITE_BURST_SEND_DATA;
5267 
5268         MDRV_MHL_MSG_INFO("** MHL sent audio tunnel port %c in %d\r\n", MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath), ucData[4]);
5269     }
5270 }
5271 
5272 //**************************************************************************
5273 //  [Function Name]:
5274 //                  mdrv_mhl_GeteMSCSupportInformation()
5275 //  [Description]
5276 //
5277 //  [Arguments]:
5278 //
5279 //  [Return]:
5280 //
5281 //**************************************************************************
_mdrv_mhl_GeteMSCSupportInformation(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate,MS_U8 * pData)5282 MS_BOOL _mdrv_mhl_GeteMSCSupportInformation(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate, MS_U8 *pData)
5283 {
5284     MS_BOOL bFinish = FALSE;
5285     MS_U8 uctemp = 0;
5286     MS_U8 ucEntryCount = 0;
5287     MS_U8 ucSequence = pMHLResourcePrivate->ucWriteBurstSequence;
5288     MS_U8 ucFinishEntry = 0;
5289     MS_U8 ucTotalEntry = MHL_EMSC_SUPPORT_TOTAL_ENTRY;
5290 
5291     ucFinishEntry = ucSequence *MHL_EMSC_SUPPORT_SEQUENCE_LENGTH;
5292 
5293     pData[0] = (MHL_BURST_ID_EMSC_SUPPORT >> 8);
5294     pData[1] = (MHL_BURST_ID_EMSC_SUPPORT &BMASK(7:0));
5295     pData[3] = ucTotalEntry;
5296 
5297     for(uctemp = 0; uctemp < MHL_EMSC_SUPPORT_SEQUENCE_LENGTH; uctemp++)
5298     {
5299         if((uctemp +ucFinishEntry) == ucTotalEntry)
5300         {
5301             break;
5302         }
5303 
5304         pData[6 +(uctemp *2)] = pMHLResourcePrivate->usEMSCSupportTable[uctemp +ucFinishEntry] >> 8;
5305         pData[7 +(uctemp *2)] = pMHLResourcePrivate->usEMSCSupportTable[uctemp +ucFinishEntry] &BMASK(7:0);
5306 
5307         ucEntryCount++;
5308     }
5309 
5310     ucSequence++;
5311 
5312     pData[4] = ucSequence;
5313     pData[5] = ucEntryCount;
5314     pData[2] = _mdrv_mhl_WriteBurstCheckSum(pData);
5315 
5316     if(((ucSequence -1) *MHL_EMSC_SUPPORT_SEQUENCE_LENGTH +ucEntryCount) == ucTotalEntry)
5317     {
5318         bFinish = TRUE;
5319         ucSequence = 0;
5320     }
5321 
5322     pMHLResourcePrivate->ucWriteBurstSequence = ucSequence;
5323 
5324     return bFinish;
5325 }
5326 
5327 //**************************************************************************
5328 //  [Function Name]:
5329 //                  _mdrv_mhl_SendeMSCSupportInformation()
5330 //  [Description]
5331 //
5332 //  [Arguments]:
5333 //
5334 //  [Return]:
5335 //
5336 //**************************************************************************
_mdrv_mhl_SendeMSCSupportInformation(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate)5337 void _mdrv_mhl_SendeMSCSupportInformation(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate)
5338 {
5339     MS_BOOL bFinish = FALSE;
5340     MS_U8 ucData[MHL_MSC_SCRATCHPAD_SIZE] = {0};
5341 
5342     if(_mdrv_mhl_GeteMSCSupportInformation(pMHLResourcePrivate, ucData))
5343     {
5344         bFinish = TRUE;
5345     }
5346 
5347     if(_mdrv_mhl_CbusSendWriteBurst(pMHLResourcePrivate, 0x40, MHL_MSC_SCRATCHPAD_SIZE, ucData))
5348     {
5349         if(bFinish)
5350         {
5351             CLR_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_EMSC_DATA_TUNNEL_FLAG);
5352         }
5353 
5354         pMHLResourcePrivate->ucWriteBurstState = MHL_CBUS_WRITE_BURST_SEND_DATA;
5355 
5356         MDRV_MHL_MSG_INFO("** MHL sent eMSC support port %c in %d\r\n", MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath), ucData[4]);
5357     }
5358 }
5359 
5360 //**************************************************************************
5361 //  [Function Name]:
5362 //                  _mdrv_mhl_SendBISTReturnStatus()
5363 //  [Description]
5364 //
5365 //  [Arguments]:
5366 //
5367 //  [Return]:
5368 //
5369 //**************************************************************************
_mdrv_mhl_SendBISTReturnStatus(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate)5370 void _mdrv_mhl_SendBISTReturnStatus(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate)
5371 {
5372     MS_U8 ucData[MHL_MSC_SCRATCHPAD_SIZE] = {0};
5373 
5374     ucData[0] = (MHL_BURST_ID_BIST_RETURN_STAT >> 8);
5375     ucData[1] = (MHL_BURST_ID_BIST_RETURN_STAT &BMASK(7:0));
5376     ucData[12] = (pMHLResourcePrivate->stBISTParameterInfo.usBISTeCbusErrorCount >> 8);
5377     ucData[13] = (pMHLResourcePrivate->stBISTParameterInfo.usBISTeCbusErrorCount &BMASK(7:0));
5378     ucData[14] = (pMHLResourcePrivate->stBISTParameterInfo.usBISTAVLinkErrorCount >> 8);
5379     ucData[15] = (pMHLResourcePrivate->stBISTParameterInfo.usBISTAVLinkErrorCount &BMASK(7:0));
5380     ucData[2] = _mdrv_mhl_WriteBurstCheckSum(ucData);
5381 
5382     if(_mdrv_mhl_CbusSendWriteBurst(pMHLResourcePrivate, 0x40, MHL_MSC_SCRATCHPAD_SIZE, ucData))
5383     {
5384         CLR_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_BIST_RETURN_STATUS_FLAG);
5385 
5386         pMHLResourcePrivate->ucWriteBurstState = MHL_CBUS_WRITE_BURST_SEND_DATA;
5387 
5388         MDRV_MHL_MSG_INFO("** MHL send BIST eCbus port %c error count %d\r\n", MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath), pMHLResourcePrivate->stBISTParameterInfo.usBISTeCbusErrorCount);
5389         MDRV_MHL_MSG_INFO("** MHL send BIST AV link port %c error count %d\r\n", MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath), pMHLResourcePrivate->stBISTParameterInfo.usBISTAVLinkErrorCount);
5390     }
5391 }
5392 
5393 //**************************************************************************
5394 //  [Function Name]:
5395 //                  _mdrv_mhl_SendWriteBurstInformation()
5396 //  [Description]
5397 //
5398 //  [Arguments]:
5399 //
5400 //  [Return]:
5401 //
5402 //**************************************************************************
_mdrv_mhl_SendWriteBurstInformation(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate)5403 void _mdrv_mhl_SendWriteBurstInformation(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate)
5404 {
5405     MS_BOOL bSendWriteBurst = FALSE;
5406     MS_U8 ucWriteBurstType = MHL_CBUS_SEND_WRITE_BURST_NONE;
5407 
5408     if(GET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_USER_WRITE_BURST_FLAG))
5409     {
5410         ucWriteBurstType = MHL_CBUS_SEND_WRITE_BURST_USER_DATA;
5411     }
5412     else if(GET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_3D_INFORMATION_FLAG))
5413     {
5414         ucWriteBurstType = MHL_CBUS_SEND_WRITE_BURST_3D_INFORMATION;
5415     }
5416     else if(GET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_VC_INFORMATION_FLAG))
5417     {
5418         ucWriteBurstType = MHL_CBUS_SEND_WRITE_BURST_VIRTUAL_CHANNEL;
5419     }
5420     else if(GET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_HIGH_END_VIDEO_FLAG))
5421     {
5422         ucWriteBurstType = MHL_CBUS_SEND_WRITE_BURST_HIGH_END_VIDEO;
5423     }
5424     else if(GET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_AUDIO_DATA_TUNNEL_FLAG))
5425     {
5426         ucWriteBurstType = MHL_CBUS_SEND_WRITE_BURST_AUDIO_DATA_TUNNEL;
5427     }
5428     else if(GET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_EMSC_DATA_TUNNEL_FLAG))
5429     {
5430         ucWriteBurstType = MHL_CBUS_SEND_WRITE_BURST_EMSC_DATA_TUNNEL;
5431     }
5432     else if(GET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_BIST_RETURN_STATUS_FLAG))
5433     {
5434         ucWriteBurstType = MHL_CBUS_SEND_WRITE_BURST_BIST_RETURN_STATUS;
5435     }
5436 
5437     if(ucWriteBurstType != MHL_CBUS_SEND_WRITE_BURST_NONE)
5438     {
5439         if(pMHLResourcePrivate->ucWriteBurstState == MHL_CBUS_WRITE_BURST_NONE)
5440         {
5441             pMHLResourcePrivate->ucWriteBurstState = MHL_CBUS_WRITE_BURST_START;
5442         }
5443         else if(pMHLResourcePrivate->ucWriteBurstState == MHL_CBUS_WRITE_BURST_REVEIVE_GRANT)
5444         {
5445             bSendWriteBurst = TRUE;
5446         }
5447     }
5448 
5449     if(bSendWriteBurst)
5450     {
5451         switch(ucWriteBurstType)
5452         {
5453             case MHL_CBUS_SEND_WRITE_BURST_3D_INFORMATION:
5454                 _mdrv_mhl_Send3DTimingInformation(pMHLResourcePrivate);
5455                 break;
5456 
5457             case MHL_CBUS_SEND_WRITE_BURST_VIRTUAL_CHANNEL:
5458                 _mdrv_mhl_SendVirtualChannelInformation(pMHLResourcePrivate);
5459                 break;
5460 
5461             case MHL_CBUS_SEND_WRITE_BURST_HIGH_END_VIDEO:
5462                 _mdrv_mhl_SendHighEndVideoSupport(pMHLResourcePrivate);
5463                 break;
5464 
5465             case MHL_CBUS_SEND_WRITE_BURST_AUDIO_DATA_TUNNEL:
5466                 _mdrv_mhl_SendAudioDataTunnelSupport(pMHLResourcePrivate);
5467                 break;
5468 
5469             case MHL_CBUS_SEND_WRITE_BURST_EMSC_DATA_TUNNEL:
5470                 _mdrv_mhl_SendeMSCSupportInformation(pMHLResourcePrivate);
5471                 break;
5472 
5473             case MHL_CBUS_SEND_WRITE_BURST_BIST_RETURN_STATUS:
5474                 _mdrv_mhl_SendBISTReturnStatus(pMHLResourcePrivate);
5475                 break;
5476 
5477             default:
5478 
5479                 break;
5480         };
5481     }
5482 }
5483 
5484 //**************************************************************************
5485 //  [Function Name]:
5486 //                  _mdrv_mhl_FeatureRequestStateProc()
5487 //  [Description]
5488 //
5489 //  [Arguments]:
5490 //
5491 //  [Return]:
5492 //
5493 //**************************************************************************
_mdrv_mhl_FeatureRequestStateProc(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate)5494 void _mdrv_mhl_FeatureRequestStateProc(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate)
5495 {
5496     switch(pMHLResourcePrivate->ucFeatureRequestState)
5497     {
5498         case MHL_CBUS_FEATURE_START:
5499             pMHLResourcePrivate->ucFeatureRequestState = MHL_CBUS_FEATURE_SEND_3D_INFORMATION;
5500             SET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_3D_INFORMATION_FLAG);
5501             SET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_3D_DTD_FLAG);
5502             SET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_3D_VIC_FLAG);
5503 
5504             break;
5505 
5506         case MHL_CBUS_FEATURE_SEND_3D_INFORMATION:
5507             if(!GET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_3D_INFORMATION_FLAG))
5508             {
5509                 pMHLResourcePrivate->ucFeatureRequestState = MHL_CBUS_FEATURE_SEND_HIGH_END_VIDEO;
5510                 SET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_HIGH_END_VIDEO_FLAG);
5511                 SET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_HEV_VIC_FLAG);
5512                 SET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_HEV_DTDA_FLAG);
5513                 SET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_HEV_DTDB_FLAG);
5514             }
5515 
5516             break;
5517 
5518         case MHL_CBUS_FEATURE_SEND_HIGH_END_VIDEO:
5519             if(!GET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_HIGH_END_VIDEO_FLAG))
5520             {
5521                 pMHLResourcePrivate->ucFeatureRequestState = MHL_CBUS_FEATURE_SEND_AUDIO_DATA_TUNNEL;
5522                 SET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_AUDIO_DATA_TUNNEL_FLAG);
5523             }
5524 
5525             break;
5526 
5527         case MHL_CBUS_FEATURE_SEND_AUDIO_DATA_TUNNEL:
5528             if(!GET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_AUDIO_DATA_TUNNEL_FLAG))
5529             {
5530                 pMHLResourcePrivate->ucFeatureRequestState = MHL_CBUS_FEATURE_SEND_EMSC_DATA_TUNNEL;
5531                 SET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_EMSC_DATA_TUNNEL_FLAG);
5532             }
5533 
5534             break;
5535 
5536         case MHL_CBUS_FEATURE_SEND_EMSC_DATA_TUNNEL:
5537             if(!GET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_EMSC_DATA_TUNNEL_FLAG))
5538             {
5539                 if(pMHLResourcePrivate->ucWriteBurstState == MHL_CBUS_WRITE_BURST_NONE)
5540                 {
5541                     pMHLResourcePrivate->ucFeatureRequestState = MHL_CBUS_FEATURE_SEND_FEATURE_COMPLETE;
5542                 }
5543             }
5544 
5545             break;
5546 
5547         case MHL_CBUS_FEATURE_SEND_FEATURE_COMPLETE:
5548             if(_mdrv_mhl_CbusWriteStatusOrSetInt(pMHLResourcePrivate, 0x20, BIT(6), FALSE))
5549             {
5550                 pMHLResourcePrivate->ucFeatureRequestState = MHL_CBUS_FEATURE_END;
5551             }
5552 
5553             break;
5554 
5555         case MHL_CBUS_FEATURE_END:
5556             pMHLResourcePrivate->ucFeatureRequestState = MHL_CBUS_FEATURE_NONE;
5557             break;
5558 
5559         default:
5560 
5561             break;
5562     };
5563 }
5564 
5565 //**************************************************************************
5566 //  [Function Name]:
5567 //                  _mapi_mhl_CbusBISTStateProc()
5568 //  [Description]
5569 //
5570 //  [Arguments]:
5571 //
5572 //  [Return]:
5573 //
5574 //**************************************************************************
_mdrv_mhl_CbusBISTStateProc(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate)5575 void _mdrv_mhl_CbusBISTStateProc(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate)
5576 {
5577     MS_U8 ucBISTECbusMode = 0;
5578 
5579     switch(pMHLResourcePrivate->ucBISTModeState)
5580     {
5581         case MHL_CBUS_BIST_RECEIVE_SETUP:
5582             if(_mdrv_mhl_CbusSendSubMessage(pMHLResourcePrivate, MSC_MSG_BIST_READY, pMHLResourcePrivate->stBISTParameterInfo.ucBISTReadyIndex, FALSE)) // Send BIST ready
5583             {
5584                 pMHLResourcePrivate->ucBISTModeState = MHL_CBUS_BIST_WAIT_TRIGGER;
5585 
5586                 mhal_mhl_SetBISTParameterInfo(pMHLResourcePrivate->ucMHLSupportPath, &(pMHLResourcePrivate->stBISTParameterInfo));
5587             }
5588 
5589             break;
5590 
5591         case MHL_CBUS_BIST_RECEIVE_TRIGGER:
5592             pMHLResourcePrivate->ucBISTModeState = MHL_CBUS_BIST_ECBUS_SWITCH;
5593             ucBISTECbusMode = MHL_RAP_KEY_CBUS_MODE_UP;
5594 
5595             MDRV_MHL_MSG_INFO("** MHL BIST receive trigger in port %c\r\n", MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath));
5596 
5597             if(pMHLResourcePrivate->stBISTParameterInfo.usBISTeCbusDuration > 0)
5598             {
5599                 MDRV_MHL_MSG_INFO("** MHL set BIST trigger timer in port %c timer %d\r\n", MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath), pMHLResourcePrivate->stBISTParameterInfo.usBISTeCbusDuration);
5600 
5601                 _mdrv_mhl_SetCbusTimerEvent(pMHLResourcePrivate, MHL_TIMER_EVENT_BIST_PROCESS, pMHLResourcePrivate->stBISTParameterInfo.usBISTeCbusDuration);
5602             }
5603 
5604             break;
5605 
5606         case MHL_CBUS_BIST_ECBUS_SWITCH:
5607             //mhal_mhl_GetBISTErrorCount(pMHLResourcePrivate->ucMHLSupportPath, &(pMHLResourcePrivate->stBISTParameterInfo));
5608             break;
5609 
5610         case MHL_CBUS_BIST_EVENT_FINISH:
5611             pMHLResourcePrivate->ucBISTModeState = MHL_CBUS_BIST_WAIT_TRIGGER;
5612             ucBISTECbusMode = MHL_RAP_KEY_CBUS_MODE_DOWN;
5613 
5614             MDRV_MHL_MSG_INFO("** MHL BIST run finish in port %c\r\n", MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath));
5615 
5616             break;
5617 
5618         case MHL_CBUS_BIST_REQUEST_STATUS:
5619             SET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_BIST_RETURN_STATUS_FLAG);
5620             pMHLResourcePrivate->ucBISTModeState = MHL_CBUS_BIST_RETURN_STATUS;
5621             break;
5622 
5623         case MHL_CBUS_BIST_RETURN_STATUS:
5624             if(!GET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_BIST_RETURN_STATUS_FLAG))
5625             {
5626                 pMHLResourcePrivate->ucBISTModeState = MHL_CBUS_BIST_WAIT_TRIGGER;
5627             }
5628             break;
5629 
5630         case MHL_CBUS_BIST_END:
5631             pMHLResourcePrivate->ucBISTModeState = MHL_CBUS_BIST_NONE;
5632             pMHLResourcePrivate->stSignalStatusInfo.bBISTEnableFlag = FALSE;
5633             break;
5634 
5635         default:
5636 
5637             break;
5638     };
5639 
5640     if(ucBISTECbusMode > 0)
5641     {
5642         if(ucBISTECbusMode == MHL_RAP_KEY_CBUS_MODE_UP)
5643         {
5644             pMHLResourcePrivate->stBISTParameterInfo.usBISTeCbusErrorCount = 0;
5645             pMHLResourcePrivate->stBISTParameterInfo.usBISTAVLinkErrorCount = 0;
5646             pMHLResourcePrivate->stSignalStatusInfo.bBISTEnableFlag = TRUE;
5647             pMHLResourcePrivate->ucECbusState = MHL_ECBUS_STATE_BIST_MODE_UP;
5648         }
5649         else if(ucBISTECbusMode == MHL_RAP_KEY_CBUS_MODE_DOWN)
5650         {
5651             pMHLResourcePrivate->ucECbusState = MHL_ECBUS_STATE_BIST_MODE_DOWN;
5652 
5653             mhal_mhl_GetBISTErrorCount(pMHLResourcePrivate->ucMHLSupportPath, &(pMHLResourcePrivate->stBISTParameterInfo));
5654         }
5655     }
5656 }
5657 
5658 //**************************************************************************
5659 //  [Function Name]:
5660 //                  _mdrv_mhl_SendEMSCDataString()
5661 //  [Description]
5662 //
5663 //  [Arguments]:
5664 //
5665 //  [Return]:
5666 //
5667 //**************************************************************************
_mdrv_mhl_SendEMSCDataString(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate,MS_U8 ucLength,MS_U8 * ucSendData)5668 MS_U8 _mdrv_mhl_SendEMSCDataString(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate, MS_U8 ucLength, MS_U8 *ucSendData)
5669 {
5670     MS_BOOL bDoAgainFlag = FALSE;
5671     MS_U8 uctemp = 0;
5672     MS_U8 ucSendStatus = 0;
5673     MS_U8 ucSendEMSC[MHL_EMSC_DATA_SIZE] = {0};
5674 
5675     do
5676     {
5677         bDoAgainFlag = FALSE;
5678 
5679         switch(pMHLResourcePrivate->ucEMSCSendStatus)
5680         {
5681             case MHL_EMSC_SEND_NONE:
5682                 if((ucLength +2) <= pMHLResourcePrivate->usEMSCTxBufferSize) // eMSC data length must small than Tx buffer +2
5683                 {
5684                     ucSendEMSC[0] = MHL_EMSC_DATA_SIZE - pMHLResourcePrivate->usEMSCRxBufferSize;
5685                     ucSendEMSC[1] = ucLength;
5686 
5687                     if(ucSendData != 0)
5688                     {
5689                         for(uctemp = 0; uctemp < ucLength; uctemp++)
5690                         {
5691                             ucSendEMSC[uctemp +2] = ucSendData[uctemp];
5692                         }
5693                     }
5694 
5695                     pMHLResourcePrivate->ucEMSCSendStatus = MHL_EMSC_SEND_DATA;
5696                     bDoAgainFlag = TRUE;
5697                 }
5698 
5699                 break;
5700 
5701             case MHL_EMSC_SEND_DATA:
5702                 ucSendStatus = mhal_mhl_GetEMSCSendStatus();
5703                 mhal_mhl_InsertEMSCSendData(ucLength +2, ucSendEMSC);
5704 
5705                 pMHLResourcePrivate->ucEMSCSendStatus = MHL_EMSC_SEND_CHECK;
5706 
5707                 break;
5708 
5709             case MHL_EMSC_SEND_CHECK:
5710                 ucSendStatus = mhal_mhl_GetEMSCSendStatus();
5711 
5712                 if(ucSendStatus != MHL_EMSC_SEND_NONE)
5713                 {
5714                     pMHLResourcePrivate->ucEMSCSendStatus = ucSendStatus;
5715                 }
5716 
5717                 break;
5718 
5719             case MHL_EMSC_SEND_PASS:
5720                 pMHLResourcePrivate->ucEMSCSendStatus = MHL_EMSC_SEND_NONE;
5721                 break;
5722 
5723             case MHL_EMSC_SEND_FAIL:
5724                 pMHLResourcePrivate->ucEMSCSendStatus = MHL_EMSC_SEND_NONE;
5725                 break;
5726 
5727             default:
5728                 pMHLResourcePrivate->ucEMSCSendStatus = MHL_EMSC_SEND_NONE;
5729                 break;
5730         };
5731     }while(bDoAgainFlag);
5732 
5733     if(pMHLResourcePrivate->ucEMSCSendStatus == MHL_EMSC_SEND_PASS)
5734     {
5735         MDRV_MHL_MSG_INFO("** MHL eMSC send pass !! port %c\r\n", MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath));
5736 
5737         pMHLResourcePrivate->usEMSCRxBufferSize = MHL_EMSC_DATA_SIZE;
5738         pMHLResourcePrivate->usEMSCTxBufferSize = pMHLResourcePrivate->usEMSCTxBufferSize -ucLength -2;
5739 
5740         MDRV_MHL_MSG_INFO("** MHL eMSC send Rx buffer size %d in port %c !!\r\n", pMHLResourcePrivate->usEMSCRxBufferSize, MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath));
5741         MDRV_MHL_MSG_INFO("** MHL eMSC send Tx buffer size %d in port %c !!\r\n", pMHLResourcePrivate->usEMSCTxBufferSize, MHL_INPUT_PORT(pMHLResourcePrivate->ucMHLSupportPath));
5742     }
5743 
5744     return pMHLResourcePrivate->ucEMSCSendStatus;
5745 }
5746 
5747 //**************************************************************************
5748 //  [Function Name]:
5749 //                  _mdrv_mhl_CheckEMSCRxBufferSize()
5750 //  [Description]
5751 //
5752 //  [Arguments]:
5753 //
5754 //  [Return]:
5755 //
5756 //**************************************************************************
_mdrv_mhl_CheckEMSCRxBufferSize(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate)5757 void _mdrv_mhl_CheckEMSCRxBufferSize(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate)
5758 {
5759     MS_U8 ucSendStatus = 0;
5760 
5761     if(pMHLResourcePrivate->usEMSCRxBufferSize < MHL_EMSC_DATA_SIZE_THRESHOLD)
5762     {
5763         ucSendStatus = _mdrv_mhl_SendEMSCDataString(pMHLResourcePrivate, 0, NULL);
5764     }
5765 }
5766 
5767 //**************************************************************************
5768 //  [Function Name]:
5769 //                  _mdrv_mhl_CbusTxHandler()
5770 //  [Description]
5771 //
5772 //  [Arguments]:
5773 //
5774 //  [Return]:
5775 //
5776 //**************************************************************************
_mdrv_mhl_CbusTxHandler(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate)5777 void _mdrv_mhl_CbusTxHandler(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate)
5778 {
5779     if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CBUS_CONNECT_FLAG))
5780     {
5781         _mdrv_mhl_TxQueueHandler(pMHLResourcePrivate);
5782 
5783         if(!GET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_CBUS_TX_QUEUE_FREEZE_FLAG))
5784         {
5785             _mdrv_mhl_SendDisplayCommand(pMHLResourcePrivate);
5786 
5787             _mdrv_mhl_WriteBurstEventProc(pMHLResourcePrivate);
5788 
5789             _mdrv_mhl_SendWriteBurstInformation(pMHLResourcePrivate);
5790 
5791             if(GET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_ECBUS_FUNCTION_FLAG))
5792             {
5793                 _mdrv_mhl_ReadExtendDeviceCapabilityProc(pMHLResourcePrivate);
5794 
5795                 _mdrv_mhl_FeatureRequestStateProc(pMHLResourcePrivate);
5796 
5797                 _mdrv_mhl_CheckEMSCRxBufferSize(pMHLResourcePrivate);
5798             }
5799 
5800             _mdrv_mhl_GetVenderIDProc(pMHLResourcePrivate);
5801 
5802             _mdrv_mhl_ReadDeviceCapabilityProc(pMHLResourcePrivate);
5803         }
5804 
5805         if(GET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_ECBUS_FUNCTION_FLAG))
5806         {
5807             _mdrv_mhl_CbusBISTStateProc(pMHLResourcePrivate);
5808         }
5809     }
5810 }
5811 
5812 //**************************************************************************
5813 //  [Function Name]:
5814 //                  _mdrv_mhl_AutoSwitchProc()
5815 //  [Description]
5816 //
5817 //  [Arguments]:
5818 //
5819 //  [Return]:
5820 //
5821 //**************************************************************************
_mdrv_mhl_AutoSwitchProc(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate)5822 void _mdrv_mhl_AutoSwitchProc(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate)
5823 {
5824     MS_BOOL bOnLinePortFlag = FALSE;
5825 
5826     if(GET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_AUTO_SWITCH_FLAG))
5827     {
5828         if(mhal_mhl_CheckInputPort(pMHLResourcePrivate->ucMHLSupportPath) && mhal_mhl_CheckPIPWindow())
5829         {
5830             bOnLinePortFlag = TRUE;
5831         }
5832 
5833         if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_AUTO_SWITCH_SETTING_FLAG))
5834         {
5835             if(GET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_WAKE_FLAG))
5836             {
5837                 CLR_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_WAKE_FLAG);
5838                 CLR_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_AUTO_SWITCH_FLAG);
5839                 CLR_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_AUTO_SWITCH_SETTING_FLAG);
5840                 SET_MHL_DONE_FLAG(pMHLResourcePrivate->ucProcDoneIndex, MHL_AUTO_SWITCH_DONE_FLAG);
5841             }
5842             else // Setting but not wake up
5843             {
5844                 if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CABLE_PLUG_FLAG))
5845                 {
5846                     mhal_mhl_VbusCharge(pMHLResourcePrivate->ucMHLSupportPath, MHL_VBUS_CHARGE_ON);
5847                 }
5848                 else
5849                 {
5850                     mhal_mhl_VbusCharge(pMHLResourcePrivate->ucMHLSupportPath, MHL_VBUS_HW_DETCET);
5851                 }
5852 
5853                 if(bOnLinePortFlag)
5854                 {
5855                     mhal_mhl_CbusWakeupIntSetting(pMHLResourcePrivate->ucMHLSupportPath, FALSE);
5856 
5857                     CLR_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_AUTO_SWITCH_SETTING_FLAG);
5858                     CLR_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_AUTO_SWITCH_FLAG);
5859                 }
5860             }
5861         }
5862         else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CBUS_CONNECT_FLAG))
5863         {
5864             CLR_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_AUTO_SWITCH_FLAG);
5865         }
5866         else // Not setting
5867         {
5868             if(!bOnLinePortFlag)
5869             {
5870                 mhal_mhl_CbusWakeupIntSetting(pMHLResourcePrivate->ucMHLSupportPath, TRUE);
5871 
5872                 SET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_AUTO_SWITCH_SETTING_FLAG);
5873             }
5874         }
5875     }
5876 }
5877 
5878 //**************************************************************************
5879 //  [Function Name]:
5880 //                  _mdrv_mhl_ForceSendClearHPD()
5881 //  [Description]
5882 //
5883 //  [Arguments]:
5884 //
5885 //  [Return]:
5886 //
5887 //**************************************************************************
_mdrv_mhl_ForceSendClearHPD(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate)5888 void _mdrv_mhl_ForceSendClearHPD(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate)
5889 {
5890     stMHL_QUEUE_INFO stCbusQueueInfo = {0};
5891 
5892     stCbusQueueInfo.ucQueueState = MHL_QUEUE_STATE_PENDING;
5893     stCbusQueueInfo.ucLength = 0;
5894     stCbusQueueInfo.ucCommand = MSC_CLR_HPD;
5895 
5896     if(_mdrv_mhl_CbusTxWriteCommand(pMHLResourcePrivate->stSignalStatusInfo.bECbusEnableFlag, &stCbusQueueInfo))
5897     {
5898         CLR_MHL_DISPLAY_FLAG(pMHLResourcePrivate->usDisplayIndex, MHL_CBUS_HPD_SET_FLAG);
5899     }
5900 }
5901 
5902 //**************************************************************************
5903 //  [Function Name]:
5904 //                  _mdrv_mhl_RtermControlHWMode()
5905 //  [Description]
5906 //
5907 //  [Arguments]:
5908 //
5909 //  [Return]:
5910 //
5911 //**************************************************************************
_mdrv_mhl_RtermControlHWMode(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate,MS_BOOL bEnableFlag)5912 void _mdrv_mhl_RtermControlHWMode(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate, MS_BOOL bEnableFlag)
5913 {
5914     if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CABLE_PLUG_FLAG))
5915     {
5916         mhal_mhl_RtermControlHWMode(pMHLResourcePrivate->ucMHLSupportPath, bEnableFlag);
5917     }
5918 }
5919 
5920 //**************************************************************************
5921 //  [Function Name]:
5922 //                  _mdrv_mhl_PollingEventProc
5923 //  [Description]:
5924 //
5925 //  [Arguments]:
5926 //
5927 //  [Return]:
5928 //
5929 //**************************************************************************
_mdrv_mhl_PollingEventProc(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate)5930 void _mdrv_mhl_PollingEventProc(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate)
5931 {
5932     _mdrv_mhl_TimerHandler(pMHLResourcePrivate);
5933 
5934     _mdrv_mhl_RtermControlHWMode(pMHLResourcePrivate, FALSE);
5935 
5936     _mdrv_mhl_CheckStatusPolling(pMHLResourcePrivate);
5937 
5938     _mdrv_mhl_RtermControlHWMode(pMHLResourcePrivate, TRUE);
5939 
5940     _mdrv_mhl_CbusRxHandler(pMHLResourcePrivate);
5941 
5942     _mdrv_mhl_CbusTxHandler(pMHLResourcePrivate);
5943 
5944     _mdrv_mhl_AutoSwitchProc(pMHLResourcePrivate);
5945 }
5946 
5947 #if(MHL_USE_UTOPIA_VERSION == MHL_UTOPIA_VERSION_10)
5948 //**************************************************************************
5949 //  [Function Name]:
5950 //                  _mdrv_mhl_ResourceGetPrivate
5951 //  [Description]:
5952 //
5953 //  [Arguments]:
5954 //
5955 //  [Return]:
5956 //
5957 //**************************************************************************
_mdrv_mhl_ResourceGetPrivate(void ** ppPrivate)5958 MS_BOOL _mdrv_mhl_ResourceGetPrivate(void** ppPrivate)
5959 {
5960     MS_BOOL bGetPrivateFlag = FALSE;
5961 
5962     *ppPrivate = &stMHLResourcePrivate;
5963 
5964     if(*ppPrivate != NULL)
5965     {
5966         bGetPrivateFlag = TRUE;
5967     }
5968 
5969     return bGetPrivateFlag;
5970 }
5971 
5972 #elif(MHL_USE_UTOPIA_VERSION == MHL_UTOPIA_VERSION_20)
5973 //**************************************************************************
5974 //  [Function Name]:
5975 //                  _mdrv_mhl_PollingTask
5976 //  [Description]:
5977 //
5978 //  [Arguments]:
5979 //
5980 //  [Return]:
5981 //
5982 //**************************************************************************
_mdrv_mhl_PollingTask(void)5983 void _mdrv_mhl_PollingTask(void)
5984 {
5985     void* pModule = NULL;
5986     void* pMHLResource = NULL;
5987     MS_BOOL bMHLTaskProcFlag = TRUE;
5988     MS_U32 usPollingTaskInterval = 0;
5989     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
5990 
5991     UtopiaModuleGetPtr(MODULE_MHL, &pModule);
5992 
5993     while(bMHLTaskProcFlag)
5994     {
5995         if(UtopiaResourceObtain(pModule, MHL_POOL, &pMHLResource) != UTOPIA_STATUS_SUCCESS)
5996         {
5997             MDRV_MHL_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
5998         }
5999         else if(UtopiaResourceGetPrivate(pMHLResource, (void*)&pMHLResourcePrivate) != UTOPIA_STATUS_SUCCESS)
6000         {
6001             MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
6002         }
6003         else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
6004         {
6005             _mdrv_mhl_PollingEventProc(pMHLResourcePrivate);
6006 
6007             if(GET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_COMMUNICATE_BUSY_FLAG))
6008             {
6009                 usPollingTaskInterval = MHL_POLLING_INTERVAL_BUSY;
6010             }
6011             else
6012             {
6013                 usPollingTaskInterval = MHL_POLLING_INTERVAL_NORMAL;
6014             }
6015 
6016             bMHLTaskProcFlag = GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_TASK_PROCESS_FLAG);
6017         }
6018 
6019         UtopiaResourceRelease(pMHLResource);
6020 
6021         MsOS_DelayTask(usPollingTaskInterval);
6022     }
6023 }
6024 
6025 //**************************************************************************
6026 //  [Function Name]:
6027 //                  _mdrv_mhl_CreateTask
6028 //  [Description]:
6029 //
6030 //  [Arguments]:
6031 //
6032 //  [Return]:
6033 //
6034 //**************************************************************************
_mdrv_mhl_CreateTask(MHL_RESOURCE_PRIVATE * pMHLResourcePrivate)6035 MS_BOOL _mdrv_mhl_CreateTask(MHL_RESOURCE_PRIVATE *pMHLResourcePrivate)
6036 {
6037     MS_BOOL bCreateSuccess = TRUE;
6038 
6039     if(pMHLResourcePrivate->slMHLPollingTaskID < 0)
6040     {
6041         pMHLResourcePrivate->slMHLPollingTaskID = MsOS_CreateTask((TaskEntry) _mdrv_mhl_PollingTask,
6042                                      (MS_VIRT) NULL,
6043                                      E_TASK_PRI_MEDIUM,
6044                                      TRUE,
6045                                      (void *)pMHLResourcePrivate->ucMHLPollingStack,
6046                                      MHL_POLLING_STACK_SIZE,
6047                                      "MHL task");
6048 
6049         SET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_TASK_PROCESS_FLAG);
6050     }
6051 
6052     if(pMHLResourcePrivate->slMHLPollingTaskID < 0)
6053     {
6054         MDRV_MHL_MSG_ERROR("MsOS_CreateTask failed!!\n");
6055 
6056         MsOS_DeleteEventGroup(pMHLResourcePrivate->slMHLPollingTaskID);
6057 
6058         bCreateSuccess = FALSE;
6059     }
6060 
6061     return bCreateSuccess;
6062 }
6063 
6064 #endif
6065 
6066 //**************************************************************************
6067 //  [Function Name]:
6068 //                  _mdrv_mhl_IsrHandler()
6069 //  [Description]
6070 //
6071 //  [Arguments]:
6072 //
6073 //  [Return]:
6074 //
6075 //**************************************************************************
_mdrv_mhl_IsrHandler(InterruptNum eIntNum)6076 static void _mdrv_mhl_IsrHandler(InterruptNum eIntNum)
6077 {
6078 #if(MHL_USE_UTOPIA_VERSION == MHL_UTOPIA_VERSION_10)
6079     MS_BOOL bGetResourceFlag = FALSE;
6080     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
6081 
6082     if(!_mdrv_mhl_ResourceGetPrivate((void*)&pMHLResourcePrivate))
6083     {
6084         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
6085     }
6086     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
6087     {
6088         bGetResourceFlag = TRUE;
6089     }
6090 
6091     UNUSED(eIntNum);
6092 
6093     //MsOS_DisableInterrupt(E_INT_IRQ_MHL_CBUS_PM);
6094 
6095     if(mhal_mhl_CbusIsMscMsgReceived() && bGetResourceFlag)
6096     {
6097         SET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_MSC_FLAG);
6098         CLR_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_RECEIVE_LOSE_FLAG);
6099 
6100         pMHLResourcePrivate->ucReceiveCounter++;
6101     }
6102 
6103     if(mhal_mhl_CbusStucktoLowFlag())
6104     {
6105         mhal_mhl_CbusStucktoLow(FALSE);
6106 
6107         if(bGetResourceFlag)
6108         {
6109             mhal_mhl_CbusStucktoLowProc(pMHLResourcePrivate->ucMHLSupportPath);
6110 
6111             mhal_mhl_CDRModeMonitor(pMHLResourcePrivate->ucMHLSupportPath, FALSE, &(pMHLResourcePrivate->stSignalStatusInfo));
6112         }
6113     }
6114 
6115     if(mhal_mhl_CbusWakeupIntFlag())
6116     {
6117         mhal_mhl_CbusWakeupInterrupt(FALSE);
6118 
6119         if(bGetResourceFlag)
6120         {
6121             SET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_WAKE_FLAG);
6122         }
6123     }
6124 
6125     if(bGetResourceFlag)
6126     {
6127         if(GET_MHL_CHIP_FLAG(pMHLResourcePrivate->ucChipCapability, MHL_CHIP_INTERRUPT_USE_PM_IRQ_FLAG))
6128         {
6129             MsOS_EnableInterrupt(E_INT_IRQ_PM);
6130         }
6131         else
6132         {
6133             MsOS_EnableInterrupt(E_INT_IRQ_MHL_CBUS_PM);
6134         }
6135     }
6136 
6137 #elif(MHL_USE_UTOPIA_VERSION == MHL_UTOPIA_VERSION_20)
6138     void* pModule = NULL;
6139     void* pMHLResource = NULL;
6140     MS_BOOL bGetResourceFlag = FALSE;
6141     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
6142 
6143     UtopiaModuleGetPtr(MODULE_MHL, &pModule);
6144 
6145     if(UtopiaResourceObtain(pModule, MHL_POOL, &pMHLResource) != UTOPIA_STATUS_SUCCESS)
6146     {
6147         MDRV_MHL_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
6148     }
6149     else if(UtopiaResourceGetPrivate(pMHLResource, (void*)&pMHLResourcePrivate) != UTOPIA_STATUS_SUCCESS)
6150     {
6151         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
6152     }
6153     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
6154     {
6155         bGetResourceFlag = TRUE;
6156     }
6157 
6158     UNUSED(eIntNum);
6159 
6160     //MsOS_DisableInterrupt(E_INT_IRQ_MHL_CBUS_PM);
6161 
6162     if(mhal_mhl_CbusIsMscMsgReceived() && bGetResourceFlag)
6163     {
6164         SET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_MSC_FLAG);
6165         CLR_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_RECEIVE_LOSE_FLAG);
6166 
6167         pMHLResourcePrivate->ucReceiveCounter++;
6168     }
6169 
6170     if(mhal_mhl_CbusStucktoLowFlag())
6171     {
6172         mhal_mhl_CbusStucktoLow(FALSE);
6173 
6174         if(bGetResourceFlag)
6175         {
6176             mhal_mhl_CbusStucktoLowProc(pMHLResourcePrivate->ucMHLSupportPath);
6177 
6178             mhal_mhl_CDRModeMonitor(pMHLResourcePrivate->ucMHLSupportPath, FALSE, &(pMHLResourcePrivate->stSignalStatusInfo));
6179         }
6180     }
6181 
6182     if(mhal_mhl_CbusWakeupIntFlag())
6183     {
6184         mhal_mhl_CbusWakeupInterrupt(FALSE);
6185 
6186         if(bGetResourceFlag)
6187         {
6188             SET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_WAKE_FLAG);
6189         }
6190     }
6191 
6192     if(bGetResourceFlag)
6193     {
6194         if(GET_MHL_CHIP_FLAG(pMHLResourcePrivate->ucChipCapability, MHL_CHIP_INTERRUPT_USE_PM_IRQ_FLAG))
6195         {
6196             MsOS_EnableInterrupt(E_INT_IRQ_PM);
6197         }
6198         else
6199         {
6200             MsOS_EnableInterrupt(E_INT_IRQ_MHL_CBUS_PM);
6201         }
6202     }
6203 
6204     UtopiaResourceRelease(pMHLResource);
6205 
6206 #endif
6207 }
6208 
6209 //**************************************************************************
6210 //  [Function Name]:
6211 //                  _mdrv_mhl_ECbusIsrHandler()
6212 //  [Description]
6213 //
6214 //  [Arguments]:
6215 //
6216 //  [Return]:
6217 //
6218 //**************************************************************************
_mdrv_mhl_ECbusIsrHandler(InterruptNum eIntNum)6219 static void _mdrv_mhl_ECbusIsrHandler(InterruptNum eIntNum)
6220 {
6221 #if(MHL_USE_UTOPIA_VERSION == MHL_UTOPIA_VERSION_10)
6222     MS_BOOL bGetResourceFlag = FALSE;
6223     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
6224 
6225     if(!_mdrv_mhl_ResourceGetPrivate((void*)&pMHLResourcePrivate))
6226     {
6227         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
6228     }
6229     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
6230     {
6231         bGetResourceFlag = TRUE;
6232     }
6233 
6234     UNUSED(eIntNum);
6235 
6236     if(bGetResourceFlag)
6237     {
6238         if(mhal_mhl_GetECbusStateChangeFlag(&(pMHLResourcePrivate->stSignalStatusInfo), &(pMHLResourcePrivate->stBISTParameterInfo)))
6239         {
6240 
6241         }
6242     }
6243     else
6244     {
6245         if(mhal_mhl_GetECbusStateChangeFlag(NULL, NULL))
6246         {
6247 
6248         }
6249     }
6250 
6251     if(mhal_mhl_GetEMSCReceiveFlag() && bGetResourceFlag)
6252     {
6253         pMHLResourcePrivate->ucEMSCReceiveCounter++;
6254     }
6255 
6256 #elif(MHL_USE_UTOPIA_VERSION == MHL_UTOPIA_VERSION_20)
6257     void* pModule = NULL;
6258     void* pMHLResource = NULL;
6259     MS_BOOL bGetResourceFlag = FALSE;
6260     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
6261 
6262     UtopiaModuleGetPtr(MODULE_MHL, &pModule);
6263 
6264     if(UtopiaResourceObtain(pModule, MHL_POOL, &pMHLResource) != UTOPIA_STATUS_SUCCESS)
6265     {
6266         MDRV_MHL_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
6267     }
6268     else if(UtopiaResourceGetPrivate(pMHLResource, (void*)&pMHLResourcePrivate) != UTOPIA_STATUS_SUCCESS)
6269     {
6270         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
6271     }
6272     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
6273     {
6274         bGetResourceFlag = TRUE;
6275     }
6276 
6277     UNUSED(eIntNum);
6278 
6279     if(bGetResourceFlag)
6280     {
6281         if(mhal_mhl_GetECbusStateChangeFlag(&(pMHLResourcePrivate->stSignalStatusInfo), &(pMHLResourcePrivate->stBISTParameterInfo)))
6282         {
6283 
6284         }
6285     }
6286     else
6287     {
6288         if(mhal_mhl_GetECbusStateChangeFlag(NULL, NULL))
6289         {
6290 
6291         }
6292     }
6293 
6294     if(mhal_mhl_GetEMSCReceiveFlag() && bGetResourceFlag)
6295     {
6296         pMHLResourcePrivate->ucEMSCReceiveCounter++;
6297     }
6298 
6299     UtopiaResourceRelease(pMHLResource);
6300 
6301 #endif
6302 
6303     MsOS_EnableInterrupt(E_INT_IRQ_MHL_ECBUS_INT);
6304 }
6305 
6306 //-------------------------------------------------------------------------------------------------
6307 //  Global Functions
6308 //-------------------------------------------------------------------------------------------------
6309 #if(MHL_USE_UTOPIA_VERSION == MHL_UTOPIA_VERSION_10)
6310 //**************************************************************************
6311 //  [Function Name]:
6312 //                  mdrv_mhl_STREventProc()
6313 //  [Description]
6314 //
6315 //  [Arguments]:
6316 //
6317 //  [Return]:
6318 //
6319 //**************************************************************************
mdrv_mhl_STREventProc(EN_POWER_MODE usPowerState)6320 MS_U32 mdrv_mhl_STREventProc(EN_POWER_MODE usPowerState)
6321 {
6322     MS_U32 ulReturnValue = UTOPIA_STATUS_FAIL;
6323     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
6324 
6325     if(!_mdrv_mhl_ResourceGetPrivate((void*)&pMHLResourcePrivate))
6326     {
6327         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
6328     }
6329     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
6330     {
6331         if(pMHLResourcePrivate->usPrePowerState != usPowerState)
6332         {
6333             if(usPowerState == E_POWER_SUSPEND)
6334             {
6335                 if(GET_MHL_DISPLAY_FLAG(pMHLResourcePrivate->usDisplayIndex, MHL_CBUS_HPD_SET_FLAG))
6336                 {
6337                     _mdrv_mhl_ForceSendClearHPD(pMHLResourcePrivate);
6338                 }
6339 
6340                 ulReturnValue = UTOPIA_STATUS_SUCCESS;
6341             }
6342             else if(usPowerState == E_POWER_RESUME)
6343             {
6344                 pMHLResourcePrivate->ucChipCapability = mhal_mhl_initial(pMHLResourcePrivate->ucMHLSupportPath, NULL, NULL, pMHLResourcePrivate->ucDeviceVenderID);
6345 
6346                 CLR_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CBUS_NORMAL_FLAG);
6347 
6348                 if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CABLE_PLUG_FLAG))
6349                 {
6350                     if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CBUS_CONNECT_FLAG))
6351                     {
6352                         mhal_mhl_ClockModeSwitchProc(pMHLResourcePrivate->ucMHLSupportPath, FALSE, &(pMHLResourcePrivate->stSignalStatusInfo));
6353 
6354                         mhal_mhl_CbusConnectProc(pMHLResourcePrivate->ucMHLSupportPath);
6355 
6356                         if(pMHLResourcePrivate->ucTMDSClockMode == MHL_PHY_CLOCK_PACKET_PIXEL)
6357                         {
6358                             mhal_mhl_ClockModeSwitchProc(pMHLResourcePrivate->ucMHLSupportPath, TRUE, &(pMHLResourcePrivate->stSignalStatusInfo));
6359                         }
6360                     }
6361                     else
6362                     {
6363                         mhal_mhl_CablePlugProc(pMHLResourcePrivate->ucMHLSupportPath, &(pMHLResourcePrivate->stSignalStatusInfo));
6364                     }
6365                 }
6366 
6367                 ulReturnValue = UTOPIA_STATUS_SUCCESS;
6368             }
6369 
6370             pMHLResourcePrivate->usPrePowerState = usPowerState;
6371         }
6372     }
6373 
6374     return ulReturnValue;
6375 }
6376 
6377 //**************************************************************************
6378 //  [Function Name]:
6379 //                  mdrv_mhl_MHLSupportPath()
6380 //  [Description]
6381 //                  MHL support path
6382 //  [Arguments]:
6383 //
6384 //  [Return]:
6385 //
6386 //**************************************************************************
mdrv_mhl_MHLSupportPath(MS_U8 ucSelect)6387 void mdrv_mhl_MHLSupportPath(MS_U8 ucSelect)
6388 {
6389     MS_BOOL bMHLEfuseFlag = TRUE;
6390     MS_U8 uctemp = 0;
6391     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
6392 
6393     if(!_mdrv_mhl_ResourceGetPrivate((void*)&pMHLResourcePrivate))
6394     {
6395         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
6396     }
6397     else
6398     {
6399         // Clear flag
6400         if(pMHLResourcePrivate->ucInitialIndex != 0xA5)
6401         {
6402             _mdrv_mhl_ClearCbusFlag(pMHLResourcePrivate, MHL_CLEAR_INITIAL_FLAG);
6403 
6404             pMHLResourcePrivate->ucInitialIndex = 0xA5;
6405 
6406             if(_mdrv_mhl_InitRiuBase(pMHLResourcePrivate)) // Get base success
6407             {
6408                 MDRV_MHL_MSG_INFO("** MHL get XC and PM base success \n");
6409 
6410                 SET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG);
6411             }
6412         }
6413         else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
6414         {
6415             mhal_mhl_SetRegisterBaseAddress(pMHLResourcePrivate->ulRiuBaseAddress, pMHLResourcePrivate->ulPMRiuBaseAddress);
6416         }
6417 
6418         mhal_mhl_MHLSupportPath(ucSelect);
6419 
6420         bMHLEfuseFlag = MDrv_SYS_Query(E_SYS_QUERY_MHL_SUPPORTED);
6421 
6422         if(mhal_mhl_CheckEfuseControlFlag(bMHLEfuseFlag))
6423         {
6424             MDRV_MHL_MSG_INFO("** MHL function not support in this chip ###\r\n");
6425         }
6426         else
6427         {
6428             for(uctemp = 0; uctemp < MHL_CBUS_SELECT_MASK ;uctemp++)
6429             {
6430                 if(ucSelect &BIT(uctemp))
6431                 {
6432                     pMHLResourcePrivate->ucMHLSupportPath = uctemp;
6433 
6434                     MDRV_MHL_MSG_INFO("** MHL function support in port %c\r\n", MHL_INPUT_PORT(uctemp));
6435                 }
6436             }
6437         }
6438     }
6439 }
6440 
6441 //**************************************************************************
6442 //  [Function Name]:
6443 //                  mdrv_mhl_Initial()
6444 //  [Description]
6445 //                  MHL init
6446 //  [Arguments]:
6447 //                  *edid: MHL EDID data
6448 //                  *devcap: MHL device capability
6449 //  [Return]:
6450 //
6451 //**************************************************************************
mdrv_mhl_Initial(MS_U8 * edid,MS_U8 * DevCap)6452 void mdrv_mhl_Initial(MS_U8 *edid, MS_U8 *DevCap)
6453 {
6454     MS_U8 uctemp = 0;
6455     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
6456 
6457     if(!_mdrv_mhl_ResourceGetPrivate((void*)&pMHLResourcePrivate))
6458     {
6459         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
6460     }
6461     else
6462     {
6463         // Clear flag
6464         if(pMHLResourcePrivate->ucInitialIndex != 0xA5)
6465         {
6466             _mdrv_mhl_ClearCbusFlag(pMHLResourcePrivate, MHL_CLEAR_INITIAL_FLAG);
6467 
6468             pMHLResourcePrivate->ucInitialIndex = 0xA5;
6469         }
6470 
6471         if(_mdrv_mhl_InitRiuBase(pMHLResourcePrivate)) // Get base success
6472         {
6473             MDRV_MHL_MSG_INFO("** MHL get XC and PM base success \n");
6474 
6475             SET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG);
6476         }
6477 
6478         if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
6479         {
6480             if(!GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_PREVENT_REINITIAL_FLAG))
6481             {
6482                 // Chip initial
6483                 pMHLResourcePrivate->ucChipCapability = mhal_mhl_initial(pMHLResourcePrivate->ucMHLSupportPath, edid, DevCap, pMHLResourcePrivate->ucDeviceVenderID);
6484 
6485                 SET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_PREVENT_REINITIAL_FLAG);
6486             }
6487             else
6488             {
6489                 // Load EDID
6490                 mhal_mhl_LoadEDID(edid);
6491 
6492                 // Load vendor ID
6493                 mhal_mhl_SetVenderID(pMHLResourcePrivate->ucDeviceVenderID);
6494 
6495                 // Load DevCap
6496                 mhal_mhl_LoadDeviceCapability(DevCap);
6497             }
6498 
6499             // Parsing EDID
6500             _mdrv_mhl_ParsingEDIDfor3D(pMHLResourcePrivate, edid);
6501 
6502             // Check and insert device capability
6503             if(DevCap != NULL)
6504             {
6505                 for(uctemp = 0; uctemp < MHL_DEVICE_CAPABILITY_SIZE; uctemp++)
6506                 {
6507                     pMHLResourcePrivate->ucDeviceCapabilityTable[uctemp] = DevCap[uctemp];
6508                 }
6509 
6510                 if(_mdrv_mhl_GetEnhanceCbusFlag(pMHLResourcePrivate)) // Chip support MHL 3.0
6511                 {
6512                     SET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CBUS_ENHANCE_FLAG);
6513 
6514                     for(uctemp = 0; uctemp < MHL_XDEVICE_CAPABILITY_SIZE; uctemp++)
6515                     {
6516                         pMHLResourcePrivate->ucDeviceCapabilityTable[MHL_DEVICE_CAPABILITY_SIZE +uctemp] = DevCap[MHL_DEVICE_CAPABILITY_SIZE +uctemp];
6517                     }
6518                 }
6519                 else if(DevCap[MHL_CBUS_VERSION] >= 0x30) // Change MHL version to 2.1
6520                 {
6521                     pMHLResourcePrivate->ucDeviceCapabilityTable[MHL_CBUS_VERSION] = 0x21;
6522 
6523                     mhal_mhl_LoadDeviceCapability(pMHLResourcePrivate->ucDeviceCapabilityTable);
6524 
6525                     MDRV_MHL_MSG_INFO("** MHL this chip not supprt MHL 3.0 \r\n");
6526                 }
6527             }
6528 
6529             // Attach Cbus ISR
6530             if(!GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CBUS_ISR_ATTACH_FLAG))
6531             {
6532                 if(GET_MHL_CHIP_FLAG(pMHLResourcePrivate->ucChipCapability, MHL_CHIP_INTERRUPT_USE_PM_IRQ_FLAG))
6533                 {
6534                     MsOS_AttachInterrupt(E_INT_IRQ_PM, _mdrv_mhl_IsrHandler);
6535                     MsOS_EnableInterrupt(E_INT_IRQ_PM);
6536                 }
6537                 else
6538                 {
6539                     MsOS_AttachInterrupt(E_INT_IRQ_MHL_CBUS_PM, _mdrv_mhl_IsrHandler);
6540                     MsOS_EnableInterrupt(E_INT_IRQ_MHL_CBUS_PM);
6541                 }
6542 
6543                 SET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CBUS_ISR_ATTACH_FLAG);
6544             }
6545 
6546             // Attach eCbus ISR
6547             if(!GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_ECBUS_ISR_ATTACH_FLAG))
6548             {
6549                 if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CBUS_ENHANCE_FLAG))
6550                 {
6551                     MsOS_AttachInterrupt(E_INT_IRQ_MHL_ECBUS_INT, _mdrv_mhl_ECbusIsrHandler);
6552                     MsOS_EnableInterrupt(E_INT_IRQ_MHL_ECBUS_INT);
6553 
6554                     SET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_ECBUS_ISR_ATTACH_FLAG);
6555                 }
6556             }
6557         }
6558     }
6559 }
6560 
6561 //**************************************************************************
6562 //  [Function Name]:
6563 //                  mdrv_mhl_Handler()
6564 //  [Description]
6565 //                  MHL handler
6566 //  [Arguments]:
6567 //
6568 //  [Return]:
6569 //
6570 //**************************************************************************
mdrv_mhl_Handler(void)6571 MS_U16 mdrv_mhl_Handler(void)
6572 {
6573     MS_U16 usMSGKeyInfo = 0;
6574     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
6575 
6576     if(!_mdrv_mhl_ResourceGetPrivate((void*)&pMHLResourcePrivate))
6577     {
6578         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
6579     }
6580     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
6581     {
6582         _mdrv_mhl_PollingEventProc(pMHLResourcePrivate);
6583 
6584         if(GET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_CALLBACK_FUNCTION_FLAG))
6585         {
6586             CLR_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_CALLBACK_FUNCTION_FLAG);
6587 
6588             usMSGKeyInfo = pMHLResourcePrivate->usMSGKeyInfo;
6589         }
6590     }
6591 
6592     return usMSGKeyInfo;
6593 }
6594 
6595 //**************************************************************************
6596 //  [Function Name]:
6597 //                  mdrv_mhl_AutoSwitchHandler()
6598 //  [Description]
6599 //
6600 //  [Arguments]:
6601 //
6602 //  [Return]:
6603 //
6604 //**************************************************************************
mdrv_mhl_AutoSwitchHandler(MS_BOOL bReset,MS_U8 * ucCbusPath)6605 MS_BOOL mdrv_mhl_AutoSwitchHandler(MS_BOOL bReset, MS_U8 *ucCbusPath)
6606 {
6607     MS_BOOL bAutoSwitchFlag = FALSE;
6608     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
6609 
6610     if(!_mdrv_mhl_ResourceGetPrivate((void*)&pMHLResourcePrivate))
6611     {
6612         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
6613     }
6614     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
6615     {
6616         if(bReset)
6617         {
6618             CLR_MHL_DONE_FLAG(pMHLResourcePrivate->ucProcDoneIndex, MHL_AUTO_SWITCH_DONE_FLAG);
6619             CLR_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_AUTO_SWITCH_FLAG);
6620         }
6621         else
6622         {
6623             if(GET_MHL_DONE_FLAG(pMHLResourcePrivate->ucProcDoneIndex, MHL_AUTO_SWITCH_DONE_FLAG))
6624             {
6625                 CLR_MHL_DONE_FLAG(pMHLResourcePrivate->ucProcDoneIndex, MHL_AUTO_SWITCH_DONE_FLAG);
6626 
6627                 _mdrv_mhl_SetCbusTimerEvent(pMHLResourcePrivate, MHL_TIMER_EVENT_AUTO_SWITCH_STOP, MHL_AUTO_SWITCH_STOP_TIME);
6628 
6629                 SET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_AUTO_SWITCH_STOP_FLAG);
6630 
6631                 bAutoSwitchFlag = TRUE;
6632             }
6633             else if(!GET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_AUTO_SWITCH_STOP_FLAG))
6634             {
6635                 if(!GET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_AUTO_SWITCH_FLAG))
6636                 {
6637                     if(!GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CBUS_CONNECT_FLAG))
6638                     {
6639                         SET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_AUTO_SWITCH_FLAG);
6640                     }
6641                 }
6642             }
6643         }
6644     }
6645 
6646     return bAutoSwitchFlag;
6647 }
6648 
6649 //**************************************************************************
6650 //  [Function Name]:
6651 //                  mdrv_mhl_SetPowerState()
6652 //  [Description]
6653 //
6654 //  [Arguments]:
6655 //
6656 //  [Return]:
6657 //
6658 //**************************************************************************
mdrv_mhl_SetPowerState(EN_POWER_MODE usPowerState)6659 MS_U32 mdrv_mhl_SetPowerState(EN_POWER_MODE usPowerState)
6660 {
6661     return mdrv_mhl_STREventProc(usPowerState);
6662 }
6663 
6664 //**************************************************************************
6665 //  [Function Name]:
6666 //                  mdrv_mhl_CbusControl()
6667 //  [Description]
6668 //
6669 //  [Arguments]:
6670 //
6671 //  [Return]:
6672 //
6673 //**************************************************************************
mdrv_mhl_CbusControl(MS_U8 ucState)6674 void mdrv_mhl_CbusControl(MS_U8 ucState)
6675 {
6676     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
6677 
6678     if(!_mdrv_mhl_ResourceGetPrivate((void*)&pMHLResourcePrivate))
6679     {
6680         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
6681     }
6682     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
6683     {
6684         switch(ucState)
6685         {
6686             case MHL_CBUS_FORCE_READY_DEVCAP:
6687                 SET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_DEVCAP_FLAG);
6688                 break;
6689 
6690             case MHL_CBUS_FORCE_RECEIVE_3D_REQ:
6691                 SET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_3D_REQ_FLAG);
6692                 break;
6693 
6694             case MHL_CBUS_FORCE_SEND_COMMAND_ENABLE:
6695                 SET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_FORCE_SEND_COMMAND_FLAG);
6696                 break;
6697 
6698             case MHL_CBUS_FORCE_SEND_COMMAND_DISABLE:
6699                 CLR_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_FORCE_SEND_COMMAND_FLAG);
6700                 break;
6701 
6702             case MHL_CBUS_CHECK_CONTEND_ON_ENABLE:
6703                 SET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CHECK_CONTENT_ENABLE_FLAG);
6704                 break;
6705 
6706             case MHL_CBUS_CHECK_CONTEND_ON_DISABLE:
6707                 CLR_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CHECK_CONTENT_ENABLE_FLAG);
6708                 break;
6709 
6710             case MHL_CBUS_ISOLATION_ON:
6711                 mhal_mhl_CbusIsolate(pMHLResourcePrivate->ucMHLSupportPath, TRUE);
6712                 break;
6713 
6714             case MHL_CBUS_ISOLATION_OFF:
6715                 mhal_mhl_CbusIsolate(pMHLResourcePrivate->ucMHLSupportPath, FALSE);
6716                 break;
6717 
6718             case MHL_CBUS_FLOATING_ON:
6719                 mhal_mhl_CbusFloating(TRUE);
6720                 break;
6721 
6722             case MHL_CBUS_FLOATING_OFF:
6723                 mhal_mhl_CbusFloating(FALSE);
6724                 break;
6725 
6726             case MHL_VBUS_HW_DETCET:
6727                 mhal_mhl_VbusCharge(pMHLResourcePrivate->ucMHLSupportPath, VBUS_HW_DETECT);
6728                 break;
6729 
6730             case MHL_VBUS_CHARGE_ON:
6731                 mhal_mhl_VbusCharge(pMHLResourcePrivate->ucMHLSupportPath, VBUS_SW_CHARGE);
6732                 break;
6733 
6734             case MHL_VBUS_CHARGE_OFF:
6735                 mhal_mhl_VbusCharge(pMHLResourcePrivate->ucMHLSupportPath, VBUS_SW_UNCHARGE);
6736                 break;
6737 
6738             default:
6739 
6740                 break;
6741         };
6742     }
6743 }
6744 
6745 //**************************************************************************
6746 //  [Function Name]:
6747 //                  mdrv_mhl_LoadEDID()
6748 //  [Description]
6749 //
6750 //  [Arguments]:
6751 //
6752 //  [Return]:
6753 //
6754 //**************************************************************************
mdrv_mhl_LoadEDID(MS_U8 * edid)6755 void mdrv_mhl_LoadEDID(MS_U8 *edid)
6756 {
6757     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
6758 
6759     if(!_mdrv_mhl_ResourceGetPrivate((void*)&pMHLResourcePrivate))
6760     {
6761         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
6762     }
6763     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
6764     {
6765         mhal_mhl_LoadEDID(edid);
6766 
6767         // Parsing EDID
6768         _mdrv_mhl_ParsingEDIDfor3D(pMHLResourcePrivate, edid);
6769     }
6770 }
6771 
6772 //**************************************************************************
6773 //  [Function Name]:
6774 //                  mdrv_mhl_ReadEDID()
6775 //  [Description]
6776 //
6777 //  [Arguments]:
6778 //
6779 //  [Return]:
6780 //
6781 //**************************************************************************
mdrv_mhl_ReadEDID(MS_U16 usSize,MS_U8 * edid)6782 void mdrv_mhl_ReadEDID(MS_U16 usSize, MS_U8 *edid)
6783 {
6784     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
6785 
6786     if(!_mdrv_mhl_ResourceGetPrivate((void*)&pMHLResourcePrivate))
6787     {
6788         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
6789     }
6790     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
6791     {
6792         if(usSize > 0)
6793         {
6794             mhal_mhl_ReadEDID(usSize, edid);
6795         }
6796     }
6797 }
6798 
6799 //**************************************************************************
6800 //  [Function Name]:
6801 //                  mdrv_mhl_LoadDeviceCapability()
6802 //  [Description]
6803 //
6804 //  [Arguments]:
6805 //
6806 //  [Return]:
6807 //
6808 //**************************************************************************
mdrv_mhl_LoadDeviceCapability(MS_U8 * devcap)6809 void mdrv_mhl_LoadDeviceCapability(MS_U8 *devcap)
6810 {
6811     MS_U8 uctemp = 0;
6812     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
6813 
6814     if(!_mdrv_mhl_ResourceGetPrivate((void*)&pMHLResourcePrivate))
6815     {
6816         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
6817     }
6818     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
6819     {
6820         if(devcap != NULL)
6821         {
6822             for(uctemp = 0; uctemp < MHL_DEVICE_CAPABILITY_SIZE; uctemp++)
6823             {
6824                 pMHLResourcePrivate->ucDeviceCapabilityTable[uctemp] = devcap[uctemp];
6825             }
6826 
6827             if(_mdrv_mhl_GetEnhanceCbusFlag(pMHLResourcePrivate)) // Chip support MHL 3.0
6828             {
6829                 SET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CBUS_ENHANCE_FLAG);
6830 
6831                 for(uctemp = 0; uctemp < MHL_XDEVICE_CAPABILITY_SIZE; uctemp++)
6832                 {
6833                     pMHLResourcePrivate->ucDeviceCapabilityTable[MHL_DEVICE_CAPABILITY_SIZE +uctemp] = devcap[MHL_DEVICE_CAPABILITY_SIZE +uctemp];
6834                 }
6835             }
6836             else if(devcap[MHL_CBUS_VERSION] >= 0x30) // Change MHL version to 2.1
6837             {
6838                 pMHLResourcePrivate->ucDeviceCapabilityTable[MHL_CBUS_VERSION] = 0x21;
6839 
6840                 mhal_mhl_LoadDeviceCapability(pMHLResourcePrivate->ucDeviceCapabilityTable);
6841 
6842                 MDRV_MHL_MSG_INFO("** MHL this chip not supprt MHL 3.0 \r\n");
6843             }
6844 
6845             // Attach eCbus ISR
6846             if(!GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_ECBUS_ISR_ATTACH_FLAG))
6847             {
6848                 if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CBUS_ENHANCE_FLAG))
6849                 {
6850                     MsOS_AttachInterrupt(E_INT_IRQ_MHL_ECBUS_INT, _mdrv_mhl_ECbusIsrHandler);
6851                     MsOS_EnableInterrupt(E_INT_IRQ_MHL_ECBUS_INT);
6852 
6853                     SET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_ECBUS_ISR_ATTACH_FLAG);
6854                 }
6855             }
6856         }
6857     }
6858 }
6859 
6860 //**************************************************************************
6861 //  [Function Name]:
6862 //                  mdrv_mhl_SetVenderID()
6863 //  [Description]
6864 //
6865 //  [Arguments]:
6866 //
6867 //  [Return]:
6868 //
6869 //**************************************************************************
mdrv_mhl_SetVenderID(MS_U8 ucVenderID)6870 void mdrv_mhl_SetVenderID(MS_U8 ucVenderID)
6871 {
6872     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
6873 
6874     if(!_mdrv_mhl_ResourceGetPrivate((void*)&pMHLResourcePrivate))
6875     {
6876         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
6877     }
6878     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
6879     {
6880         pMHLResourcePrivate->ucDeviceVenderID = ucVenderID;
6881 
6882         mhal_mhl_SetVenderID(ucVenderID);
6883     }
6884 }
6885 
6886 //**************************************************************************
6887 //  [Function Name]:
6888 //                  mdrv_mhl_InvertCableDetect()
6889 //  [Description]
6890 //
6891 //  [Arguments]:
6892 //
6893 //  [Return]:
6894 //
6895 //**************************************************************************
mdrv_mhl_InvertCableDetect(MS_BOOL bCableDetectInvert)6896 void mdrv_mhl_InvertCableDetect(MS_BOOL bCableDetectInvert)
6897 {
6898     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
6899 
6900     if(!_mdrv_mhl_ResourceGetPrivate((void*)&pMHLResourcePrivate))
6901     {
6902         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
6903     }
6904     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
6905     {
6906         mhal_mhl_InvertCableDetect(pMHLResourcePrivate->ucMHLSupportPath, bCableDetectInvert);
6907     }
6908 }
6909 
6910 //**************************************************************************
6911 //  [Function Name]:
6912 //                  mdrv_mhl_VbusConfigSetting()
6913 //  [Description]
6914 //
6915 //  [Arguments]:
6916 //
6917 //  [Return]:
6918 //
6919 //**************************************************************************
mdrv_mhl_VbusConfigSetting(MS_U8 ucState)6920 void mdrv_mhl_VbusConfigSetting(MS_U8 ucState)
6921 {
6922     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
6923 
6924     if(!_mdrv_mhl_ResourceGetPrivate((void*)&pMHLResourcePrivate))
6925     {
6926         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
6927     }
6928     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
6929     {
6930         mhal_mhl_VbusConfigSetting(pMHLResourcePrivate->ucMHLSupportPath, ucState);
6931     }
6932 }
6933 
6934 //**************************************************************************
6935 //  [Function Name]:
6936 //                  mdrv_mhl_AdjustSettingIControl()
6937 //  [Description]
6938 //
6939 //  [Arguments]:
6940 //
6941 //  [Return]:
6942 //
6943 //**************************************************************************
mdrv_mhl_AdjustSettingIControl(MS_U8 ucIControl)6944 void mdrv_mhl_AdjustSettingIControl(MS_U8 ucIControl)
6945 {
6946     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
6947 
6948     if(!_mdrv_mhl_ResourceGetPrivate((void*)&pMHLResourcePrivate))
6949     {
6950         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
6951     }
6952     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
6953     {
6954         pMHLResourcePrivate->stSignalStatusInfo.ucIControlValue = ucIControl;
6955     }
6956 }
6957 
6958 //**************************************************************************
6959 //  [Function Name]:
6960 //                  mdrv_mhl_AdjustImpedanceSetting()
6961 //  [Description]
6962 //
6963 //  [Arguments]:
6964 //
6965 //  [Return]:
6966 //
6967 //**************************************************************************
mdrv_mhl_AdjustImpedanceSetting(MS_U8 ucImpedance)6968 void mdrv_mhl_AdjustImpedanceSetting(MS_U8 ucImpedance)
6969 {
6970     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
6971 
6972     if(!_mdrv_mhl_ResourceGetPrivate((void*)&pMHLResourcePrivate))
6973     {
6974         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
6975     }
6976     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
6977     {
6978         pMHLResourcePrivate->stSignalStatusInfo.ucImpedanceOffset = ucImpedance;
6979     }
6980 }
6981 
6982 //**************************************************************************
6983 //  [Function Name]:
6984 //                  mdrv_mhl_GetCableDetectFlag()
6985 //  [Description]
6986 //
6987 //  [Arguments]:
6988 //
6989 //  [Return]:
6990 //
6991 //**************************************************************************
mdrv_mhl_GetCableDetectFlag(void)6992 MS_BOOL mdrv_mhl_GetCableDetectFlag(void)
6993 {
6994     MS_BOOL bStatusFlag = FALSE;
6995     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
6996 
6997     if(!_mdrv_mhl_ResourceGetPrivate((void*)&pMHLResourcePrivate))
6998     {
6999         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
7000     }
7001     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
7002     {
7003         bStatusFlag = GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CABLE_PLUG_FLAG);
7004     }
7005 
7006     return bStatusFlag;
7007 }
7008 
7009 //**************************************************************************
7010 //  [Function Name]:
7011 //                  mdrv_mhl_GetCbusConnectFlag()
7012 //  [Description]
7013 //
7014 //  [Arguments]:
7015 //
7016 //  [Return]:
7017 //
7018 //**************************************************************************
mdrv_mhl_GetCbusConnectFlag(void)7019 MS_BOOL mdrv_mhl_GetCbusConnectFlag(void)
7020 {
7021     MS_BOOL bStatusFlag = FALSE;
7022     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
7023 
7024     if(!_mdrv_mhl_ResourceGetPrivate((void*)&pMHLResourcePrivate))
7025     {
7026         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
7027     }
7028     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
7029     {
7030         bStatusFlag = GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CBUS_CONNECT_FLAG);
7031     }
7032 
7033     return bStatusFlag;
7034 }
7035 
7036 //**************************************************************************
7037 //  [Function Name]:
7038 //                  mdrv_mhl_CbusWakeupIntFlag()
7039 //  [Description]
7040 //
7041 //  [Arguments]:
7042 //
7043 //  [Return]:
7044 //
7045 //**************************************************************************
mdrv_mhl_CbusWakeupIntFlag(void)7046 MS_BOOL mdrv_mhl_CbusWakeupIntFlag(void)
7047 {
7048     MS_BOOL bStatusFlag = FALSE;
7049     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
7050 
7051     if(!_mdrv_mhl_ResourceGetPrivate((void*)&pMHLResourcePrivate))
7052     {
7053         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
7054     }
7055     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
7056     {
7057         bStatusFlag = GET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_WAKE_FLAG);
7058     }
7059 
7060     return bStatusFlag;
7061 }
7062 
7063 //**************************************************************************
7064 //  [Function Name]:
7065 //                  mdrv_mhl_SrcRCPSupportFlag()
7066 //  [Description]
7067 //
7068 //  [Arguments]:
7069 //
7070 //  [Return]:
7071 //
7072 //**************************************************************************
mdrv_mhl_SrcRCPSupportFlag(void)7073 MS_BOOL mdrv_mhl_SrcRCPSupportFlag(void)
7074 {
7075     MS_BOOL bStatusFlag = FALSE;
7076     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
7077 
7078     if(!_mdrv_mhl_ResourceGetPrivate((void*)&pMHLResourcePrivate))
7079     {
7080         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
7081     }
7082     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
7083     {
7084         bStatusFlag = GET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_RCP_FUNCTION_FLAG);
7085     }
7086 
7087     return bStatusFlag;
7088 }
7089 
7090 //**************************************************************************
7091 //  [Function Name]:
7092 //                  mdrv_mhl_SrcRAPSupportFlag()
7093 //  [Description]
7094 //
7095 //  [Arguments]:
7096 //
7097 //  [Return]:
7098 //
7099 //**************************************************************************
mdrv_mhl_SrcRAPSupportFlag(void)7100 MS_BOOL mdrv_mhl_SrcRAPSupportFlag(void)
7101 {
7102     MS_BOOL bStatusFlag = FALSE;
7103     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
7104 
7105     if(!_mdrv_mhl_ResourceGetPrivate((void*)&pMHLResourcePrivate))
7106     {
7107         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
7108     }
7109     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
7110     {
7111         bStatusFlag = GET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_RAP_FUNCTION_FLAG);
7112     }
7113 
7114     return bStatusFlag;
7115 }
7116 
7117 //**************************************************************************
7118 //  [Function Name]:
7119 //                  mdrv_mhl_CbusGetStatusFlag()
7120 //  [Description]
7121 //
7122 //  [Arguments]:
7123 //
7124 //  [Return]:
7125 //
7126 //**************************************************************************
mdrv_mhl_CbusGetStatusFlag(MS_U8 ucState)7127 MS_BOOL mdrv_mhl_CbusGetStatusFlag(MS_U8 ucState)
7128 {
7129     MS_BOOL bStatusFlag = FALSE;
7130     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
7131 
7132     if(!_mdrv_mhl_ResourceGetPrivate((void*)&pMHLResourcePrivate))
7133     {
7134         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
7135     }
7136     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
7137     {
7138         switch(ucState)
7139         {
7140             case MHL_CBUS_STATUS_FLAG_CABLE_DETECT:
7141                 bStatusFlag = GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CABLE_PLUG_FLAG);
7142                 break;
7143 
7144             case MHL_CBUS_STATUS_FLAG_CBUS_CONNECT:
7145                 bStatusFlag = GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CBUS_CONNECT_FLAG);
7146                 break;
7147 
7148             case MHL_CBUS_STATUS_FLAG_PATH_EN:
7149                 break;
7150 
7151             case MHL_CBUS_STATUS_FLAG_RECEIVE_PATH_EN:
7152                 break;
7153 
7154             case MHL_CBUS_STATUS_FLAG_RECEIVE_MUTED:
7155                 break;
7156 
7157             case MHL_CBUS_STATUS_FLAG_COMMUNICATE_BUSY:
7158                 bStatusFlag = GET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_COMMUNICATE_BUSY_FLAG);
7159                 break;
7160 
7161             default:
7162 
7163                 break;
7164         };
7165     }
7166 
7167     return bStatusFlag;
7168 }
7169 
7170 //**************************************************************************
7171 //  [Function Name]:
7172 //                  mdrv_mhl_SendRAPCommand
7173 //  [Description]
7174 //                  MHL Cbus MSC Send RAP Command
7175 //  [Arguments]:
7176 //
7177 //  [Return]:
7178 //                  TRUE: success
7179 //                  FALSE: fail
7180 //**************************************************************************
mdrv_mhl_SendRAPCommand(MS_U8 ucKeyCode)7181 MS_BOOL mdrv_mhl_SendRAPCommand(MS_U8 ucKeyCode)
7182 {
7183     MS_BOOL bSendFlag = FALSE;
7184     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
7185 
7186     if(!_mdrv_mhl_ResourceGetPrivate((void*)&pMHLResourcePrivate))
7187     {
7188         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
7189     }
7190     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
7191     {
7192         bSendFlag = _mdrv_mhl_CbusSendSubMessage(pMHLResourcePrivate, MSC_MSG_RAP, ucKeyCode, TRUE);
7193     }
7194 
7195     return bSendFlag;
7196 }
7197 
7198 //**************************************************************************
7199 //  [Function Name]:
7200 //                  mdrv_mhl_SendRCPAutoReleaseCmd
7201 //  [Description]
7202 //                  MHL Cbus MSC Send RCP Command
7203 //  [Arguments]:
7204 //
7205 //  [Return]:
7206 //                  TRUE: success
7207 //                  FALSE: fail
7208 //**************************************************************************
mdrv_mhl_SendRCPAutoReleaseCmd(MS_U8 ucKeyCode)7209 MS_BOOL mdrv_mhl_SendRCPAutoReleaseCmd(MS_U8 ucKeyCode)
7210 {
7211     MS_BOOL bSendFlag = FALSE;
7212     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
7213 
7214     if(!_mdrv_mhl_ResourceGetPrivate((void*)&pMHLResourcePrivate))
7215     {
7216         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
7217     }
7218     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
7219     {
7220         if(pMHLResourcePrivate->ucPreRCPKeyCode != ucKeyCode) // Key change
7221         {
7222             if(!GET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_RCP_RELEASE_ENABLE_FLAG))
7223             {
7224                 bSendFlag = _mdrv_mhl_CbusSendSubMessage(pMHLResourcePrivate, MSC_MSG_RCP, ucKeyCode, TRUE);
7225             }
7226         }
7227         else
7228         {
7229             bSendFlag = _mdrv_mhl_CbusSendSubMessage(pMHLResourcePrivate, MSC_MSG_RCP, ucKeyCode, TRUE);
7230         }
7231 
7232         if(bSendFlag)
7233         {
7234             pMHLResourcePrivate->ucPreRCPKeyCode = ucKeyCode;
7235 
7236             _mdrv_mhl_SetCbusTimerEvent(pMHLResourcePrivate, MHL_TIMER_EVENT_RCP_AUTO_RELEASE, MHL_CBUS_RCP_RELEASE_TIME);
7237 
7238             SET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_RCP_RELEASE_ENABLE_FLAG);
7239         }
7240     }
7241 
7242     return bSendFlag;
7243 }
7244 
7245 //**************************************************************************
7246 //  [Function Name]:
7247 //                  mdrv_mhl_SendUCPCommand
7248 //  [Description]
7249 //                  MHL Cbus MSC Send UCP Command
7250 //  [Arguments]:
7251 //
7252 //  [Return]:
7253 //                  TRUE: success
7254 //                  FALSE: fail
7255 //**************************************************************************
mdrv_mhl_SendUCPCommand(MS_U8 ucKeyCode)7256 MS_BOOL mdrv_mhl_SendUCPCommand(MS_U8 ucKeyCode)
7257 {
7258     MS_BOOL bSendFlag = FALSE;
7259     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
7260 
7261     if(!_mdrv_mhl_ResourceGetPrivate((void*)&pMHLResourcePrivate))
7262     {
7263         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
7264     }
7265     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
7266     {
7267         bSendFlag = _mdrv_mhl_CbusSendSubMessage(pMHLResourcePrivate, MSC_MSG_UCP, ucKeyCode, TRUE);
7268     }
7269 
7270     return bSendFlag;
7271 }
7272 
7273 //**************************************************************************
7274 //  [Function Name]:
7275 //                  mdrv_mhl_SendWriteBurst
7276 //  [Description]
7277 //
7278 //  [Arguments]:
7279 //
7280 //  [Return]:
7281 //                  TRUE: success
7282 //                  FALSE: fail
7283 //**************************************************************************
mdrv_mhl_SendWriteBurst(MS_U8 ucAddr,MS_U8 ucLength,MS_U8 * ucData)7284 MS_BOOL mdrv_mhl_SendWriteBurst(MS_U8 ucAddr, MS_U8 ucLength, MS_U8 *ucData)
7285 {
7286     MS_BOOL bSendFlag = FALSE;
7287     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
7288 
7289     if(!_mdrv_mhl_ResourceGetPrivate((void*)&pMHLResourcePrivate))
7290     {
7291         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
7292     }
7293     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
7294     {
7295         bSendFlag = _mdrv_mhl_CbusSendWriteBurst(pMHLResourcePrivate, ucAddr, ucLength, ucData);
7296     }
7297 
7298     return bSendFlag;
7299 }
7300 
7301 //**************************************************************************
7302 //  [Function Name]:
7303 //                  mdrv_mhl_CbusSendUserWriteBurst
7304 //  [Description]
7305 //
7306 //  [Arguments]:
7307 //
7308 //  [Return]:
7309 //                  TRUE: success
7310 //                  FALSE: fail
7311 //**************************************************************************
mdrv_mhl_CbusSendUserWriteBurst(MS_U8 ucLength,MS_U8 * ucData)7312 MS_BOOL mdrv_mhl_CbusSendUserWriteBurst(MS_U8 ucLength, MS_U8 *ucData)
7313 {
7314     MS_BOOL bSendFlag = FALSE;
7315     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
7316 
7317     if(!_mdrv_mhl_ResourceGetPrivate((void*)&pMHLResourcePrivate))
7318     {
7319         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
7320     }
7321     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
7322     {
7323         if(GET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_USER_WRITE_BURST_FLAG))
7324         {
7325             if(pMHLResourcePrivate->ucWriteBurstState == MHL_CBUS_WRITE_BURST_REVEIVE_GRANT)
7326             {
7327                 if(_mdrv_mhl_CbusSendWriteBurst(pMHLResourcePrivate, 0x40, ucLength, ucData))
7328                 {
7329                     CLR_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_USER_WRITE_BURST_FLAG);
7330 
7331                     pMHLResourcePrivate->ucWriteBurstState = MHL_CBUS_WRITE_BURST_SEND_DATA;
7332 
7333                     bSendFlag = TRUE;
7334                 }
7335             }
7336         }
7337         else if(pMHLResourcePrivate->ucWriteBurstState == MHL_CBUS_WRITE_BURST_NONE)
7338         {
7339             SET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_USER_WRITE_BURST_FLAG);
7340         }
7341     }
7342 
7343     return bSendFlag;
7344 }
7345 
7346 //**************************************************************************
7347 //  [Function Name]:
7348 //                  mdrv_mhl_GetDeviceCapability
7349 //  [Description]
7350 //
7351 //  [Arguments]:
7352 //
7353 //  [Return]:
7354 //
7355 //**************************************************************************
mdrv_mhl_GetDeviceCapability(MS_U16 usDevcapMask,MS_U8 * ucDevcap)7356 MS_BOOL mdrv_mhl_GetDeviceCapability(MS_U16 usDevcapMask, MS_U8 *ucDevcap)
7357 {
7358     MS_BOOL bDoneFlag = FALSE;
7359     MS_U8 uctemp = 0;
7360     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
7361 
7362     if(!_mdrv_mhl_ResourceGetPrivate((void*)&pMHLResourcePrivate))
7363     {
7364         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
7365     }
7366     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
7367     {
7368         if(!GET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_READ_DEVCAP_FLAG))
7369         {
7370             pMHLResourcePrivate->usReadDevcapMask = usDevcapMask;
7371         }
7372 
7373         if(GET_MHL_DONE_FLAG(pMHLResourcePrivate->ucProcDoneIndex, MHL_READ_DEVCAP_DONE_FLAG))
7374         {
7375             if(ucDevcap != NULL)
7376             {
7377                 for(uctemp = 0; uctemp < MHL_DEVICE_CAPABILITY_SIZE; uctemp++)
7378                 {
7379                     if(usDevcapMask &BIT(uctemp))
7380                     {
7381                         ucDevcap[uctemp] = pMHLResourcePrivate->ucSourceDevcapTable[uctemp];
7382                     }
7383                     else
7384                     {
7385                         ucDevcap[uctemp] = 0;
7386                     }
7387                 }
7388             }
7389 
7390             bDoneFlag = TRUE;
7391         }
7392     }
7393 
7394     return bDoneFlag;
7395 }
7396 
7397 //**************************************************************************
7398 //  [Function Name]:
7399 //                  mdrv_mhl_GetExtendDeviceCapability
7400 //  [Description]
7401 //
7402 //  [Arguments]:
7403 //
7404 //  [Return]:
7405 //
7406 //**************************************************************************
mdrv_mhl_GetExtendDeviceCapability(MS_U16 usExtendDevcapMask,MS_U8 * ucExtendDevcap)7407 MS_BOOL mdrv_mhl_GetExtendDeviceCapability(MS_U16 usExtendDevcapMask, MS_U8 *ucExtendDevcap)
7408 {
7409     MS_BOOL bDoneFlag = FALSE;
7410     MS_U8 uctemp = 0;
7411     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
7412 
7413     if(!_mdrv_mhl_ResourceGetPrivate((void*)&pMHLResourcePrivate))
7414     {
7415         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
7416     }
7417     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
7418     {
7419         if(!GET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_READ_XDEVCAP_FLAG))
7420         {
7421             pMHLResourcePrivate->usReadExtendDevcapMask = usExtendDevcapMask;
7422         }
7423 
7424         if(GET_MHL_DONE_FLAG(pMHLResourcePrivate->ucProcDoneIndex, MHL_READ_XDEVCAP_DONE_FLAG))
7425         {
7426             if(ucExtendDevcap != NULL)
7427             {
7428                 for(uctemp = 0; uctemp < MHL_XDEVICE_CAPABILITY_SIZE; uctemp++)
7429                 {
7430                     if(usExtendDevcapMask &BIT(uctemp))
7431                     {
7432                         ucExtendDevcap[uctemp] = pMHLResourcePrivate->ucSourceDevcapTable[MHL_DEVICE_CAPABILITY_SIZE +uctemp];
7433                     }
7434                     else
7435                     {
7436                         ucExtendDevcap[uctemp] = 0;
7437                     }
7438                 }
7439             }
7440 
7441             bDoneFlag = TRUE;
7442         }
7443     }
7444 
7445     return bDoneFlag;
7446 }
7447 
7448 //**************************************************************************
7449 //  [Function Name]:
7450 //                  mdrv_mhl_GetDeviceVenderID
7451 //  [Description]
7452 //
7453 //  [Arguments]:
7454 //
7455 //  [Return]:
7456 //
7457 //**************************************************************************
mdrv_mhl_GetDeviceVenderID(MS_U8 * ucVenderID)7458 MS_BOOL mdrv_mhl_GetDeviceVenderID(MS_U8 *ucVenderID)
7459 {
7460     MS_BOOL bDoneFlag = FALSE;
7461     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
7462 
7463     if(!_mdrv_mhl_ResourceGetPrivate((void*)&pMHLResourcePrivate))
7464     {
7465         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
7466     }
7467     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
7468     {
7469         if(GET_MHL_DONE_FLAG(pMHLResourcePrivate->ucProcDoneIndex, MHL_GET_VENDER_ID_DONE_FLAG))
7470         {
7471             *ucVenderID = pMHLResourcePrivate->ucSourceVenderID;
7472 
7473             bDoneFlag = TRUE;
7474         }
7475         else
7476         {
7477             SET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_GET_VENDER_ID_FLAG);
7478         }
7479     }
7480 
7481     return bDoneFlag;
7482 }
7483 
7484 //**************************************************************************
7485 //  [Function Name]:
7486 //                  mdrv_mhl_GetWriteBurstData
7487 //  [Description]
7488 //
7489 //  [Arguments]:
7490 //
7491 //  [Return]:
7492 //
7493 //**************************************************************************
mdrv_mhl_GetWriteBurstData(MS_U8 * ucData)7494 MS_BOOL mdrv_mhl_GetWriteBurstData(MS_U8 *ucData)
7495 {
7496     MS_BOOL bDoneFlag = FALSE;
7497     MS_U8 uctemp = 0;
7498     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
7499 
7500     if(!_mdrv_mhl_ResourceGetPrivate((void*)&pMHLResourcePrivate))
7501     {
7502         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
7503     }
7504     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
7505     {
7506         if(pMHLResourcePrivate->ucWriteBurstAddress > 0)
7507         {
7508             pMHLResourcePrivate->ucWriteBurstAddress = 0;
7509 
7510             for(uctemp = 0; uctemp < pMHLResourcePrivate->ucWriteBurstLength; uctemp++)
7511             {
7512                 ucData[uctemp] = pMHLResourcePrivate->ucWriteBurstInformation[uctemp];
7513             }
7514 
7515             bDoneFlag = TRUE;
7516         }
7517     }
7518 
7519     return bDoneFlag;
7520 }
7521 
7522 //**************************************************************************
7523 //  [Function Name]:
7524 //                  mdrv_mhl_RegisterCallBackFunctions()
7525 //  [Description]
7526 //                  RCP &RAP call back
7527 //  [Arguments]:
7528 //
7529 //  [Return]:
7530 //
7531 //**************************************************************************
mdrv_mhl_RegisterCallBackFunctions(MS_BOOL bRCPfunctionFlag,MS_BOOL bRAPfunctionFlag)7532 void mdrv_mhl_RegisterCallBackFunctions(MS_BOOL bRCPfunctionFlag, MS_BOOL bRAPfunctionFlag)
7533 {
7534     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
7535 
7536     if(!_mdrv_mhl_ResourceGetPrivate((void*)&pMHLResourcePrivate))
7537     {
7538         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
7539     }
7540     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
7541     {
7542         if(bRCPfunctionFlag)
7543         {
7544             SET_MHL_CALLBACK_FLAG(pMHLResourcePrivate->ucCallBackFunctionIndex, MHL_CALLBACK_RCP_FUNCTION_FLAG);
7545         }
7546 
7547         if(bRAPfunctionFlag)
7548         {
7549             SET_MHL_CALLBACK_FLAG(pMHLResourcePrivate->ucCallBackFunctionIndex, MHL_CALLBACK_RAP_FUNCTION_FLAG);
7550         }
7551     }
7552 }
7553 
7554 //**************************************************************************
7555 //  [Function Name]:
7556 //                  mdrv_mhl_RegisterRcpCallBackFunction()
7557 //  [Description]
7558 //                  RCP call back
7559 //  [Arguments]:
7560 //
7561 //  [Return]:
7562 //
7563 //**************************************************************************
mdrv_mhl_RegisterRcpCallBackFunction(MS_BOOL bRCPfunctionFlag)7564 void mdrv_mhl_RegisterRcpCallBackFunction(MS_BOOL bRCPfunctionFlag)
7565 {
7566     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
7567 
7568     if(!_mdrv_mhl_ResourceGetPrivate((void*)&pMHLResourcePrivate))
7569     {
7570         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
7571     }
7572     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
7573     {
7574         if(bRCPfunctionFlag)
7575         {
7576             SET_MHL_CALLBACK_FLAG(pMHLResourcePrivate->ucCallBackFunctionIndex, MHL_CALLBACK_RCP_FUNCTION_FLAG);
7577         }
7578     }
7579 }
7580 
7581 //**************************************************************************
7582 //  [Function Name]:
7583 //                  mdrv_mhl_RegisterRapCallBackFunction()
7584 //  [Description]
7585 //                  RAP call back
7586 //  [Arguments]:
7587 //
7588 //  [Return]:
7589 //
7590 //**************************************************************************
mdrv_mhl_RegisterRapCallBackFunction(MS_BOOL bRAPfunctionFlag)7591 void mdrv_mhl_RegisterRapCallBackFunction(MS_BOOL bRAPfunctionFlag)
7592 {
7593     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
7594 
7595     if(!_mdrv_mhl_ResourceGetPrivate((void*)&pMHLResourcePrivate))
7596     {
7597         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
7598     }
7599     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
7600     {
7601         if(bRAPfunctionFlag)
7602         {
7603             SET_MHL_CALLBACK_FLAG(pMHLResourcePrivate->ucCallBackFunctionIndex, MHL_CALLBACK_RAP_FUNCTION_FLAG);
7604         }
7605     }
7606 }
7607 
7608 //**************************************************************************
7609 //  [Function Name]:
7610 //                  mdrv_mhl_RegisterUcpCallBackFunction()
7611 //  [Description]
7612 //                  UCP call back
7613 //  [Arguments]:
7614 //
7615 //  [Return]:
7616 //
7617 //**************************************************************************
mdrv_mhl_RegisterUcpCallBackFunction(MS_BOOL bUCPfunctionFlag)7618 void mdrv_mhl_RegisterUcpCallBackFunction(MS_BOOL bUCPfunctionFlag)
7619 {
7620     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
7621 
7622     if(!_mdrv_mhl_ResourceGetPrivate((void*)&pMHLResourcePrivate))
7623     {
7624         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
7625     }
7626     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
7627     {
7628         if(bUCPfunctionFlag)
7629         {
7630             SET_MHL_CALLBACK_FLAG(pMHLResourcePrivate->ucCallBackFunctionIndex, MHL_CALLBACK_UCP_FUNCTION_FLAG);
7631         }
7632     }
7633 }
7634 
7635 //**************************************************************************
7636 //  [Function Name]:
7637 //                  mdrv_mhl_RegisterAttCallBackFunction()
7638 //  [Description]
7639 //                  ATT call back
7640 //  [Arguments]:
7641 //
7642 //  [Return]:
7643 //
7644 //**************************************************************************
mdrv_mhl_RegisterAttCallBackFunction(MS_BOOL bATTfunctionFlag)7645 void mdrv_mhl_RegisterAttCallBackFunction(MS_BOOL bATTfunctionFlag)
7646 {
7647     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
7648 
7649     if(!_mdrv_mhl_ResourceGetPrivate((void*)&pMHLResourcePrivate))
7650     {
7651         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
7652     }
7653     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
7654     {
7655         if(bATTfunctionFlag)
7656         {
7657             SET_MHL_CALLBACK_FLAG(pMHLResourcePrivate->ucCallBackFunctionIndex, MHL_CALLBACK_ATT_FUNCTION_FLAG);
7658         }
7659     }
7660 }
7661 
7662 //**************************************************************************
7663 //  [Function Name]:
7664 //                  mdrv_mhl_RegisterRbpCallBackFunction()
7665 //  [Description]
7666 //                  RBP call back
7667 //  [Arguments]:
7668 //
7669 //  [Return]:
7670 //
7671 //**************************************************************************
mdrv_mhl_RegisterRbpCallBackFunction(MS_BOOL bRBPfunctionFlag)7672 void mdrv_mhl_RegisterRbpCallBackFunction(MS_BOOL bRBPfunctionFlag)
7673 {
7674     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
7675 
7676     if(!_mdrv_mhl_ResourceGetPrivate((void*)&pMHLResourcePrivate))
7677     {
7678         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
7679     }
7680     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
7681     {
7682         if(bRBPfunctionFlag)
7683         {
7684             SET_MHL_CALLBACK_FLAG(pMHLResourcePrivate->ucCallBackFunctionIndex, MHL_CALLBACK_RBP_FUNCTION_FLAG);
7685         }
7686     }
7687 }
7688 
7689 //**************************************************************************
7690 //  [Function Name]:
7691 //                  mdrv_mhl_GetConfiguration()
7692 //  [Description]
7693 //                  MHL get init config
7694 //  [Arguments]:
7695 //
7696 //  [Return]:
7697 //
7698 //**************************************************************************
mdrv_mhl_GetConfiguration(void)7699 stMHL_INITIAL_CONFIG_INFO mdrv_mhl_GetConfiguration(void)
7700 {
7701     MS_U8 uctemp = 0;
7702     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
7703     stMHL_INITIAL_CONFIG_INFO stInitialConfigInfo;
7704 
7705     if(!_mdrv_mhl_ResourceGetPrivate((void*)&pMHLResourcePrivate))
7706     {
7707         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
7708     }
7709     else
7710     {
7711         if(_mdrv_mhl_InitRiuBase(pMHLResourcePrivate)) // Get base success
7712         {
7713             MDRV_MHL_MSG_INFO("** MHL get XC and PM base success \n");
7714         }
7715 
7716         if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_PREVENT_REINITIAL_FLAG))
7717         {
7718             stInitialConfigInfo.ulReturnValue = UTOPIA_STATUS_SUCCESS;
7719             stInitialConfigInfo.ucMHLSupportPath = pMHLResourcePrivate->ucMHLSupportPath;
7720 
7721             for(uctemp = 0; uctemp < (MHL_DEVICE_CAPABILITY_SIZE +MHL_XDEVICE_CAPABILITY_SIZE); uctemp++)
7722             {
7723                 stInitialConfigInfo.ucDeviceCapabilityTable[uctemp] = pMHLResourcePrivate->ucDeviceCapabilityTable[uctemp];
7724             }
7725         }
7726     }
7727 
7728     return stInitialConfigInfo;
7729 }
7730 
7731 #elif(MHL_USE_UTOPIA_VERSION == MHL_UTOPIA_VERSION_20)
7732 //**************************************************************************
7733 //  [Function Name]:
7734 //                  mdrv_mhl_STREventProc()
7735 //  [Description]
7736 //
7737 //  [Arguments]:
7738 //
7739 //  [Return]:
7740 //
7741 //**************************************************************************
mdrv_mhl_STREventProc(void * pModule,EN_POWER_MODE usPowerState)7742 MS_U32 mdrv_mhl_STREventProc(void* pModule, EN_POWER_MODE usPowerState)
7743 {
7744     void* pMHLResource = NULL;
7745     MS_U32 ulReturnValue = UTOPIA_STATUS_FAIL;
7746     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
7747 
7748     if(UtopiaResourceObtain(pModule, MHL_POOL, &pMHLResource) != UTOPIA_STATUS_SUCCESS)
7749     {
7750         MDRV_MHL_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
7751     }
7752     else if(UtopiaResourceGetPrivate(pMHLResource, (void*)&pMHLResourcePrivate) != UTOPIA_STATUS_SUCCESS)
7753     {
7754         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
7755     }
7756     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
7757     {
7758         if(pMHLResourcePrivate->usPrePowerState != usPowerState)
7759         {
7760             if(usPowerState == E_POWER_SUSPEND)
7761             {
7762                 if(GET_MHL_DISPLAY_FLAG(pMHLResourcePrivate->usDisplayIndex, MHL_CBUS_HPD_SET_FLAG))
7763                 {
7764                     _mdrv_mhl_ForceSendClearHPD(pMHLResourcePrivate);
7765                 }
7766 
7767                 ulReturnValue = UTOPIA_STATUS_SUCCESS;
7768             }
7769             else if(usPowerState == E_POWER_RESUME)
7770             {
7771 #if defined(MSOS_TYPE_LINUX_KERNEL)
7772                 UtopiaStrWaitCondition("mhl", usPowerState, 0);
7773 #endif
7774                 pMHLResourcePrivate->ucChipCapability = mhal_mhl_initial(pMHLResourcePrivate->ucMHLSupportPath, NULL, NULL, pMHLResourcePrivate->ucDeviceVenderID);
7775 
7776                 CLR_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CBUS_NORMAL_FLAG);
7777 
7778                 if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CABLE_PLUG_FLAG))
7779                 {
7780                     if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CBUS_CONNECT_FLAG))
7781                     {
7782                         mhal_mhl_ClockModeSwitchProc(pMHLResourcePrivate->ucMHLSupportPath, FALSE, &(pMHLResourcePrivate->stSignalStatusInfo));
7783 
7784                         mhal_mhl_CbusConnectProc(pMHLResourcePrivate->ucMHLSupportPath);
7785 
7786                         if(pMHLResourcePrivate->ucTMDSClockMode == MHL_PHY_CLOCK_PACKET_PIXEL)
7787                         {
7788                             mhal_mhl_ClockModeSwitchProc(pMHLResourcePrivate->ucMHLSupportPath, TRUE, &(pMHLResourcePrivate->stSignalStatusInfo));
7789                         }
7790                     }
7791                     else
7792                     {
7793                         mhal_mhl_CablePlugProc(pMHLResourcePrivate->ucMHLSupportPath, &(pMHLResourcePrivate->stSignalStatusInfo));
7794                     }
7795                 }
7796 
7797                 ulReturnValue = UTOPIA_STATUS_SUCCESS;
7798             }
7799 
7800             pMHLResourcePrivate->usPrePowerState = usPowerState;
7801         }
7802     }
7803 
7804     UtopiaResourceRelease(pMHLResource);
7805 
7806     return ulReturnValue;
7807 }
7808 
7809 //**************************************************************************
7810 //  [Function Name]:
7811 //                  mdrv_mhl_MHLSupportPath()
7812 //  [Description]
7813 //                  MHL support path
7814 //  [Arguments]:
7815 //
7816 //  [Return]:
7817 //
7818 //**************************************************************************
mdrv_mhl_MHLSupportPath(void * pInstance,MS_U8 ucSelect)7819 void mdrv_mhl_MHLSupportPath(void* pInstance, MS_U8 ucSelect)
7820 {
7821     void* pModule = NULL;
7822     void* pMHLResource = NULL;
7823     MS_BOOL bMHLEfuseFlag = TRUE;
7824     MS_U8 uctemp = 0;
7825     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
7826 
7827     UtopiaInstanceGetModule(pInstance, &pModule);
7828 
7829     if(UtopiaResourceObtain(pModule, MHL_POOL, &pMHLResource) != UTOPIA_STATUS_SUCCESS)
7830     {
7831         MDRV_MHL_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
7832     }
7833     else if(UtopiaResourceGetPrivate(pMHLResource, (void*)&pMHLResourcePrivate) != UTOPIA_STATUS_SUCCESS)
7834     {
7835         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
7836     }
7837     else
7838     {
7839         // Clear flag
7840         if(pMHLResourcePrivate->ucInitialIndex != 0xA5)
7841         {
7842             _mdrv_mhl_ClearCbusFlag(pMHLResourcePrivate, MHL_CLEAR_INITIAL_FLAG);
7843 
7844             pMHLResourcePrivate->ucInitialIndex = 0xA5;
7845 
7846             if(_mdrv_mhl_InitRiuBase(pMHLResourcePrivate)) // Get base success
7847             {
7848                 MDRV_MHL_MSG_INFO("** MHL get XC and PM base success \n");
7849 
7850                 SET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG);
7851             }
7852         }
7853         else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
7854         {
7855             mhal_mhl_SetRegisterBaseAddress(pMHLResourcePrivate->ulRiuBaseAddress, pMHLResourcePrivate->ulPMRiuBaseAddress);
7856         }
7857 
7858         mhal_mhl_MHLSupportPath(ucSelect);
7859 
7860         bMHLEfuseFlag = MDrv_SYS_Query(E_SYS_QUERY_MHL_SUPPORTED);
7861 
7862         if(mhal_mhl_CheckEfuseControlFlag(bMHLEfuseFlag))
7863         {
7864             MDRV_MHL_MSG_INFO("** MHL function not support in this chip ###\r\n");
7865         }
7866         else
7867         {
7868             for(uctemp = 0; uctemp < MHL_CBUS_SELECT_MASK ;uctemp++)
7869             {
7870                 if(ucSelect &BIT(uctemp))
7871                 {
7872                     pMHLResourcePrivate->ucMHLSupportPath = uctemp;
7873 
7874                     MDRV_MHL_MSG_INFO("** MHL function support in port %c\r\n", MHL_INPUT_PORT(uctemp));
7875                 }
7876             }
7877         }
7878     }
7879 
7880     UtopiaResourceRelease(pMHLResource);
7881 }
7882 
7883 //**************************************************************************
7884 //  [Function Name]:
7885 //                  mdrv_mhl_Initial()
7886 //  [Description]
7887 //                  MHL init
7888 //  [Arguments]:
7889 //                  *edid: MHL EDID data
7890 //                  *devcap: MHL device capability
7891 //  [Return]:
7892 //
7893 //**************************************************************************
mdrv_mhl_Initial(void * pInstance,MS_U8 * edid,MS_U8 * DevCap)7894 void mdrv_mhl_Initial(void* pInstance, MS_U8 *edid, MS_U8 *DevCap)
7895 {
7896     void* pModule = NULL;
7897     void* pMHLResource = NULL;
7898     MS_U8 uctemp = 0;
7899     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
7900 
7901     UtopiaInstanceGetModule(pInstance, &pModule);
7902 
7903     if(UtopiaResourceObtain(pModule, MHL_POOL, &pMHLResource) != UTOPIA_STATUS_SUCCESS)
7904     {
7905         MDRV_MHL_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
7906     }
7907     else if(UtopiaResourceGetPrivate(pMHLResource, (void*)&pMHLResourcePrivate) != UTOPIA_STATUS_SUCCESS)
7908     {
7909         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
7910     }
7911     else
7912     {
7913         // Clear flag
7914         if(pMHLResourcePrivate->ucInitialIndex != 0xA5)
7915         {
7916             _mdrv_mhl_ClearCbusFlag(pMHLResourcePrivate, MHL_CLEAR_INITIAL_FLAG);
7917 
7918             pMHLResourcePrivate->ucInitialIndex = 0xA5;
7919         }
7920 
7921         if(_mdrv_mhl_InitRiuBase(pMHLResourcePrivate)) // Get base success
7922         {
7923             MDRV_MHL_MSG_INFO("** MHL get XC and PM base success \n");
7924 
7925             SET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG);
7926         }
7927 
7928         if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
7929         {
7930             if(!GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_PREVENT_REINITIAL_FLAG))
7931             {
7932                 // Chip initial
7933                 pMHLResourcePrivate->ucChipCapability = mhal_mhl_initial(pMHLResourcePrivate->ucMHLSupportPath, edid, DevCap, pMHLResourcePrivate->ucDeviceVenderID);
7934 
7935                 SET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_PREVENT_REINITIAL_FLAG);
7936             }
7937             else
7938             {
7939                 // Load EDID
7940                 mhal_mhl_LoadEDID(edid);
7941 
7942                 // Load vendor ID
7943                 mhal_mhl_SetVenderID(pMHLResourcePrivate->ucDeviceVenderID);
7944 
7945                 // Load DevCap
7946                 mhal_mhl_LoadDeviceCapability(DevCap);
7947             }
7948 
7949             // Parsing EDID
7950             _mdrv_mhl_ParsingEDIDfor3D(pMHLResourcePrivate, edid);
7951 
7952             // Check and insert device capability
7953             if(DevCap != NULL)
7954             {
7955                 for(uctemp = 0; uctemp < MHL_DEVICE_CAPABILITY_SIZE; uctemp++)
7956                 {
7957                     pMHLResourcePrivate->ucDeviceCapabilityTable[uctemp] = DevCap[uctemp];
7958                 }
7959 
7960                 if(_mdrv_mhl_GetEnhanceCbusFlag(pMHLResourcePrivate)) // Chip support MHL 3.0
7961                 {
7962                     SET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CBUS_ENHANCE_FLAG);
7963 
7964                     for(uctemp = 0; uctemp < MHL_XDEVICE_CAPABILITY_SIZE; uctemp++)
7965                     {
7966                         pMHLResourcePrivate->ucDeviceCapabilityTable[MHL_DEVICE_CAPABILITY_SIZE +uctemp] = DevCap[MHL_DEVICE_CAPABILITY_SIZE +uctemp];
7967                     }
7968                 }
7969                 else if(DevCap[MHL_CBUS_VERSION] >= 0x30) // Change MHL version to 2.1
7970                 {
7971                     pMHLResourcePrivate->ucDeviceCapabilityTable[MHL_CBUS_VERSION] = 0x21;
7972 
7973                     mhal_mhl_LoadDeviceCapability(pMHLResourcePrivate->ucDeviceCapabilityTable);
7974 
7975                     MDRV_MHL_MSG_INFO("** MHL this chip not supprt MHL 3.0 \r\n");
7976                 }
7977             }
7978 
7979             // Attach Cbus ISR
7980             if(!GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CBUS_ISR_ATTACH_FLAG))
7981             {
7982                 if(GET_MHL_CHIP_FLAG(pMHLResourcePrivate->ucChipCapability, MHL_CHIP_INTERRUPT_USE_PM_IRQ_FLAG))
7983                 {
7984                     MsOS_AttachInterrupt(E_INT_IRQ_PM, _mdrv_mhl_IsrHandler);
7985                     MsOS_EnableInterrupt(E_INT_IRQ_PM);
7986                 }
7987                 else
7988                 {
7989                     MsOS_AttachInterrupt(E_INT_IRQ_MHL_CBUS_PM, _mdrv_mhl_IsrHandler);
7990                     MsOS_EnableInterrupt(E_INT_IRQ_MHL_CBUS_PM);
7991                 }
7992 
7993                 SET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CBUS_ISR_ATTACH_FLAG);
7994             }
7995 
7996             // Attach eCbus ISR
7997             if(!GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_ECBUS_ISR_ATTACH_FLAG))
7998             {
7999                 if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CBUS_ENHANCE_FLAG))
8000                 {
8001                     MsOS_AttachInterrupt(E_INT_IRQ_MHL_ECBUS_INT, _mdrv_mhl_ECbusIsrHandler);
8002                     MsOS_EnableInterrupt(E_INT_IRQ_MHL_ECBUS_INT);
8003 
8004                     SET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_ECBUS_ISR_ATTACH_FLAG);
8005                 }
8006             }
8007 
8008             if(GET_MHL_CHIP_FLAG(pMHLResourcePrivate->ucChipCapability, MHL_CHIP_SELF_CREATE_TASK_FLAG))
8009             {
8010                 if(!GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_SELF_CREATE_TASK_FLAG))
8011                 {
8012                     if(_mdrv_mhl_CreateTask(pMHLResourcePrivate))
8013                     {
8014                         MDRV_MHL_MSG_INFO("** MHL create polling task by self \r\n");
8015 
8016                         SET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_SELF_CREATE_TASK_FLAG);
8017                     }
8018                 }
8019             }
8020         }
8021     }
8022 
8023     UtopiaResourceRelease(pMHLResource);
8024 }
8025 
8026 //**************************************************************************
8027 //  [Function Name]:
8028 //                  mdrv_mhl_Handler()
8029 //  [Description]
8030 //                  MHL handler
8031 //  [Arguments]:
8032 //
8033 //  [Return]:
8034 //
8035 //**************************************************************************
mdrv_mhl_Handler(void * pInstance)8036 MS_U16 mdrv_mhl_Handler(void* pInstance)
8037 {
8038     void* pModule = NULL;
8039     void* pMHLResource = NULL;
8040     MS_U16 usMSGKeyInfo = 0;
8041     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
8042 
8043     UtopiaInstanceGetModule(pInstance, &pModule);
8044 
8045     if(UtopiaResourceObtain(pModule, MHL_POOL, &pMHLResource) != UTOPIA_STATUS_SUCCESS)
8046     {
8047         MDRV_MHL_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
8048     }
8049     else if(UtopiaResourceGetPrivate(pMHLResource, (void*)&pMHLResourcePrivate) != UTOPIA_STATUS_SUCCESS)
8050     {
8051         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
8052     }
8053     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
8054     {
8055         if(!GET_MHL_CHIP_FLAG(pMHLResourcePrivate->ucChipCapability, MHL_CHIP_SELF_CREATE_TASK_FLAG))
8056         {
8057             _mdrv_mhl_PollingEventProc(pMHLResourcePrivate);
8058         }
8059 
8060         if(GET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_CALLBACK_FUNCTION_FLAG))
8061         {
8062             CLR_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_CALLBACK_FUNCTION_FLAG);
8063 
8064             usMSGKeyInfo = pMHLResourcePrivate->usMSGKeyInfo;
8065         }
8066     }
8067 
8068     UtopiaResourceRelease(pMHLResource);
8069 
8070     return usMSGKeyInfo;
8071 }
8072 
8073 //**************************************************************************
8074 //  [Function Name]:
8075 //                  mdrv_mhl_AutoSwitchHandler()
8076 //  [Description]
8077 //
8078 //  [Arguments]:
8079 //
8080 //  [Return]:
8081 //
8082 //**************************************************************************
mdrv_mhl_AutoSwitchHandler(void * pInstance,MS_BOOL bReset,MS_U8 * ucCbusPath)8083 MS_BOOL mdrv_mhl_AutoSwitchHandler(void* pInstance, MS_BOOL bReset, MS_U8 *ucCbusPath)
8084 {
8085     void* pModule = NULL;
8086     void* pMHLResource = NULL;
8087     MS_BOOL bAutoSwitchFlag = FALSE;
8088     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
8089 
8090     UtopiaInstanceGetModule(pInstance, &pModule);
8091 
8092     if(UtopiaResourceObtain(pModule, MHL_POOL, &pMHLResource) != UTOPIA_STATUS_SUCCESS)
8093     {
8094         MDRV_MHL_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
8095     }
8096     else if(UtopiaResourceGetPrivate(pMHLResource, (void*)&pMHLResourcePrivate) != UTOPIA_STATUS_SUCCESS)
8097     {
8098         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
8099     }
8100     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
8101     {
8102         if(bReset)
8103         {
8104             CLR_MHL_DONE_FLAG(pMHLResourcePrivate->ucProcDoneIndex, MHL_AUTO_SWITCH_DONE_FLAG);
8105             CLR_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_AUTO_SWITCH_FLAG);
8106         }
8107         else
8108         {
8109             if(GET_MHL_DONE_FLAG(pMHLResourcePrivate->ucProcDoneIndex, MHL_AUTO_SWITCH_DONE_FLAG))
8110             {
8111                 CLR_MHL_DONE_FLAG(pMHLResourcePrivate->ucProcDoneIndex, MHL_AUTO_SWITCH_DONE_FLAG);
8112 
8113                 _mdrv_mhl_SetCbusTimerEvent(pMHLResourcePrivate, MHL_TIMER_EVENT_AUTO_SWITCH_STOP, MHL_AUTO_SWITCH_STOP_TIME);
8114 
8115                 SET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_AUTO_SWITCH_STOP_FLAG);
8116 
8117                 bAutoSwitchFlag = TRUE;
8118             }
8119             else if(!GET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_AUTO_SWITCH_STOP_FLAG))
8120             {
8121                 if(!GET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_AUTO_SWITCH_FLAG))
8122                 {
8123                     if(!GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CBUS_CONNECT_FLAG))
8124                     {
8125                         SET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_AUTO_SWITCH_FLAG);
8126                     }
8127                 }
8128             }
8129         }
8130     }
8131 
8132     UtopiaResourceRelease(pMHLResource);
8133 
8134     return bAutoSwitchFlag;
8135 }
8136 
8137 //**************************************************************************
8138 //  [Function Name]:
8139 //                  mdrv_mhl_SetPowerState()
8140 //  [Description]
8141 //
8142 //  [Arguments]:
8143 //
8144 //  [Return]:
8145 //
8146 //**************************************************************************
mdrv_mhl_SetPowerState(void * pInstance,EN_POWER_MODE usPowerState)8147 MS_U32 mdrv_mhl_SetPowerState(void* pInstance, EN_POWER_MODE usPowerState)
8148 {
8149     void* pModule = NULL;
8150 
8151     UtopiaInstanceGetModule(pInstance, &pModule);
8152 
8153     return mdrv_mhl_STREventProc(pModule, usPowerState);
8154 }
8155 
8156 //**************************************************************************
8157 //  [Function Name]:
8158 //                  mdrv_mhl_CbusControl()
8159 //  [Description]
8160 //
8161 //  [Arguments]:
8162 //
8163 //  [Return]:
8164 //
8165 //**************************************************************************
mdrv_mhl_CbusControl(void * pInstance,MS_U8 ucState)8166 void mdrv_mhl_CbusControl(void* pInstance, MS_U8 ucState)
8167 {
8168     void* pModule = NULL;
8169     void* pMHLResource = NULL;
8170     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
8171 
8172     UtopiaInstanceGetModule(pInstance, &pModule);
8173 
8174     if(UtopiaResourceObtain(pModule, MHL_POOL, &pMHLResource) != UTOPIA_STATUS_SUCCESS)
8175     {
8176         MDRV_MHL_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
8177     }
8178     else if(UtopiaResourceGetPrivate(pMHLResource, (void*)&pMHLResourcePrivate) != UTOPIA_STATUS_SUCCESS)
8179     {
8180         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
8181     }
8182     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
8183     {
8184         switch(ucState)
8185         {
8186             case MHL_CBUS_FORCE_READY_DEVCAP:
8187                 SET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_DEVCAP_FLAG);
8188                 break;
8189 
8190             case MHL_CBUS_FORCE_RECEIVE_3D_REQ:
8191                 SET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_3D_REQ_FLAG);
8192                 break;
8193 
8194             case MHL_CBUS_FORCE_SEND_COMMAND_ENABLE:
8195                 SET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_FORCE_SEND_COMMAND_FLAG);
8196                 break;
8197 
8198             case MHL_CBUS_FORCE_SEND_COMMAND_DISABLE:
8199                 CLR_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_FORCE_SEND_COMMAND_FLAG);
8200                 break;
8201 
8202             case MHL_CBUS_CHECK_CONTEND_ON_ENABLE:
8203                 SET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CHECK_CONTENT_ENABLE_FLAG);
8204                 break;
8205 
8206             case MHL_CBUS_CHECK_CONTEND_ON_DISABLE:
8207                 CLR_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CHECK_CONTENT_ENABLE_FLAG);
8208                 break;
8209 
8210             case MHL_CBUS_ISOLATION_ON:
8211                 mhal_mhl_CbusIsolate(pMHLResourcePrivate->ucMHLSupportPath, TRUE);
8212                 break;
8213 
8214             case MHL_CBUS_ISOLATION_OFF:
8215                 mhal_mhl_CbusIsolate(pMHLResourcePrivate->ucMHLSupportPath, FALSE);
8216                 break;
8217 
8218             case MHL_CBUS_FLOATING_ON:
8219                 mhal_mhl_CbusFloating(TRUE);
8220                 break;
8221 
8222             case MHL_CBUS_FLOATING_OFF:
8223                 mhal_mhl_CbusFloating(FALSE);
8224                 break;
8225 
8226             case MHL_VBUS_HW_DETCET:
8227                 mhal_mhl_VbusCharge(pMHLResourcePrivate->ucMHLSupportPath, VBUS_HW_DETECT);
8228                 break;
8229 
8230             case MHL_VBUS_CHARGE_ON:
8231                 mhal_mhl_VbusCharge(pMHLResourcePrivate->ucMHLSupportPath, VBUS_SW_CHARGE);
8232                 break;
8233 
8234             case MHL_VBUS_CHARGE_OFF:
8235                 mhal_mhl_VbusCharge(pMHLResourcePrivate->ucMHLSupportPath, VBUS_SW_UNCHARGE);
8236                 break;
8237 
8238             default:
8239 
8240                 break;
8241         };
8242     }
8243 
8244     UtopiaResourceRelease(pMHLResource);
8245 }
8246 
8247 //**************************************************************************
8248 //  [Function Name]:
8249 //                  mdrv_mhl_LoadEDID()
8250 //  [Description]
8251 //
8252 //  [Arguments]:
8253 //
8254 //  [Return]:
8255 //
8256 //**************************************************************************
mdrv_mhl_LoadEDID(void * pInstance,MS_U8 * edid)8257 void mdrv_mhl_LoadEDID(void* pInstance, MS_U8 *edid)
8258 {
8259     void* pModule = NULL;
8260     void* pMHLResource = NULL;
8261     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
8262 
8263     UtopiaInstanceGetModule(pInstance, &pModule);
8264 
8265     if(UtopiaResourceObtain(pModule, MHL_POOL, &pMHLResource) != UTOPIA_STATUS_SUCCESS)
8266     {
8267         MDRV_MHL_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
8268     }
8269     else if(UtopiaResourceGetPrivate(pMHLResource, (void*)&pMHLResourcePrivate) != UTOPIA_STATUS_SUCCESS)
8270     {
8271         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
8272     }
8273     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
8274     {
8275         mhal_mhl_LoadEDID(edid);
8276 
8277         // Parsing EDID
8278         _mdrv_mhl_ParsingEDIDfor3D(pMHLResourcePrivate, edid);
8279     }
8280 
8281     UtopiaResourceRelease(pMHLResource);
8282 }
8283 
8284 //**************************************************************************
8285 //  [Function Name]:
8286 //                  mdrv_mhl_ReadEDID()
8287 //  [Description]
8288 //
8289 //  [Arguments]:
8290 //
8291 //  [Return]:
8292 //
8293 //**************************************************************************
mdrv_mhl_ReadEDID(void * pInstance,MS_U16 usSize,MS_U8 * edid)8294 void mdrv_mhl_ReadEDID(void* pInstance, MS_U16 usSize, MS_U8 *edid)
8295 {
8296     void* pModule = NULL;
8297     void* pMHLResource = NULL;
8298     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
8299 
8300     UtopiaInstanceGetModule(pInstance, &pModule);
8301 
8302     if(UtopiaResourceObtain(pModule, MHL_POOL, &pMHLResource) != UTOPIA_STATUS_SUCCESS)
8303     {
8304         MDRV_MHL_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
8305     }
8306     else if(UtopiaResourceGetPrivate(pMHLResource, (void*)&pMHLResourcePrivate) != UTOPIA_STATUS_SUCCESS)
8307     {
8308         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
8309     }
8310     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
8311     {
8312         if(usSize > 0)
8313         {
8314             mhal_mhl_ReadEDID(usSize, edid);
8315         }
8316     }
8317 
8318     UtopiaResourceRelease(pMHLResource);
8319 }
8320 
8321 //**************************************************************************
8322 //  [Function Name]:
8323 //                  mdrv_mhl_LoadDeviceCapability()
8324 //  [Description]
8325 //
8326 //  [Arguments]:
8327 //
8328 //  [Return]:
8329 //
8330 //**************************************************************************
mdrv_mhl_LoadDeviceCapability(void * pInstance,MS_U8 * devcap)8331 void mdrv_mhl_LoadDeviceCapability(void* pInstance, MS_U8 *devcap)
8332 {
8333     void* pModule = NULL;
8334     void* pMHLResource = NULL;
8335     MS_U8 uctemp = 0;
8336     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
8337 
8338     UtopiaInstanceGetModule(pInstance, &pModule);
8339 
8340     if(UtopiaResourceObtain(pModule, MHL_POOL, &pMHLResource) != UTOPIA_STATUS_SUCCESS)
8341     {
8342         MDRV_MHL_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
8343     }
8344     else if(UtopiaResourceGetPrivate(pMHLResource, (void*)&pMHLResourcePrivate) != UTOPIA_STATUS_SUCCESS)
8345     {
8346         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
8347     }
8348     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
8349     {
8350         if(devcap != NULL)
8351         {
8352             for(uctemp = 0; uctemp < MHL_DEVICE_CAPABILITY_SIZE; uctemp++)
8353             {
8354                 pMHLResourcePrivate->ucDeviceCapabilityTable[uctemp] = devcap[uctemp];
8355             }
8356 
8357             if(_mdrv_mhl_GetEnhanceCbusFlag(pMHLResourcePrivate)) // Chip support MHL 3.0
8358             {
8359                 SET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CBUS_ENHANCE_FLAG);
8360 
8361                 for(uctemp = 0; uctemp < MHL_XDEVICE_CAPABILITY_SIZE; uctemp++)
8362                 {
8363                     pMHLResourcePrivate->ucDeviceCapabilityTable[MHL_DEVICE_CAPABILITY_SIZE +uctemp] = devcap[MHL_DEVICE_CAPABILITY_SIZE +uctemp];
8364                 }
8365             }
8366             else if(devcap[MHL_CBUS_VERSION] >= 0x30) // Change MHL version to 2.1
8367             {
8368                 pMHLResourcePrivate->ucDeviceCapabilityTable[MHL_CBUS_VERSION] = 0x21;
8369 
8370                 mhal_mhl_LoadDeviceCapability(pMHLResourcePrivate->ucDeviceCapabilityTable);
8371 
8372                 MDRV_MHL_MSG_INFO("** MHL this chip not supprt MHL 3.0 \r\n");
8373             }
8374 
8375             // Attach eCbus ISR
8376             if(!GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_ECBUS_ISR_ATTACH_FLAG))
8377             {
8378                 if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CBUS_ENHANCE_FLAG))
8379                 {
8380                     MsOS_AttachInterrupt(E_INT_IRQ_MHL_ECBUS_INT, _mdrv_mhl_ECbusIsrHandler);
8381                     MsOS_EnableInterrupt(E_INT_IRQ_MHL_ECBUS_INT);
8382 
8383                     SET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_ECBUS_ISR_ATTACH_FLAG);
8384                 }
8385             }
8386         }
8387     }
8388 
8389     UtopiaResourceRelease(pMHLResource);
8390 }
8391 
8392 //**************************************************************************
8393 //  [Function Name]:
8394 //                  mdrv_mhl_SetVenderID()
8395 //  [Description]
8396 //
8397 //  [Arguments]:
8398 //
8399 //  [Return]:
8400 //
8401 //**************************************************************************
mdrv_mhl_SetVenderID(void * pInstance,MS_U8 ucVenderID)8402 void mdrv_mhl_SetVenderID(void* pInstance, MS_U8 ucVenderID)
8403 {
8404     void* pModule = NULL;
8405     void* pMHLResource = NULL;
8406     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
8407 
8408     UtopiaInstanceGetModule(pInstance, &pModule);
8409 
8410     if(UtopiaResourceObtain(pModule, MHL_POOL, &pMHLResource) != UTOPIA_STATUS_SUCCESS)
8411     {
8412         MDRV_MHL_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
8413     }
8414     else if(UtopiaResourceGetPrivate(pMHLResource, (void*)&pMHLResourcePrivate) != UTOPIA_STATUS_SUCCESS)
8415     {
8416         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
8417     }
8418     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
8419     {
8420         pMHLResourcePrivate->ucDeviceVenderID = ucVenderID;
8421 
8422         mhal_mhl_SetVenderID(ucVenderID);
8423     }
8424 
8425     UtopiaResourceRelease(pMHLResource);
8426 }
8427 
8428 //**************************************************************************
8429 //  [Function Name]:
8430 //                  mdrv_mhl_InvertCableDetect()
8431 //  [Description]
8432 //
8433 //  [Arguments]:
8434 //
8435 //  [Return]:
8436 //
8437 //**************************************************************************
mdrv_mhl_InvertCableDetect(void * pInstance,MS_BOOL bCableDetectInvert)8438 void mdrv_mhl_InvertCableDetect(void* pInstance, MS_BOOL bCableDetectInvert)
8439 {
8440     void* pModule = NULL;
8441     void* pMHLResource = NULL;
8442     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
8443 
8444     UtopiaInstanceGetModule(pInstance, &pModule);
8445 
8446     if(UtopiaResourceObtain(pModule, MHL_POOL, &pMHLResource) != UTOPIA_STATUS_SUCCESS)
8447     {
8448         MDRV_MHL_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
8449     }
8450     else if(UtopiaResourceGetPrivate(pMHLResource, (void*)&pMHLResourcePrivate) != UTOPIA_STATUS_SUCCESS)
8451     {
8452         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
8453     }
8454     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
8455     {
8456         mhal_mhl_InvertCableDetect(pMHLResourcePrivate->ucMHLSupportPath, bCableDetectInvert);
8457     }
8458 
8459     UtopiaResourceRelease(pMHLResource);
8460 }
8461 
8462 //**************************************************************************
8463 //  [Function Name]:
8464 //                  mdrv_mhl_VbusConfigSetting()
8465 //  [Description]
8466 //
8467 //  [Arguments]:
8468 //
8469 //  [Return]:
8470 //
8471 //**************************************************************************
mdrv_mhl_VbusConfigSetting(void * pInstance,MS_U8 ucState)8472 void mdrv_mhl_VbusConfigSetting(void* pInstance, MS_U8 ucState)
8473 {
8474     void* pModule = NULL;
8475     void* pMHLResource = NULL;
8476     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
8477 
8478     UtopiaInstanceGetModule(pInstance, &pModule);
8479 
8480     if(UtopiaResourceObtain(pModule, MHL_POOL, &pMHLResource) != UTOPIA_STATUS_SUCCESS)
8481     {
8482         MDRV_MHL_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
8483     }
8484     else if(UtopiaResourceGetPrivate(pMHLResource, (void*)&pMHLResourcePrivate) != UTOPIA_STATUS_SUCCESS)
8485     {
8486         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
8487     }
8488     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
8489     {
8490         mhal_mhl_VbusConfigSetting(pMHLResourcePrivate->ucMHLSupportPath, ucState);
8491     }
8492 
8493     UtopiaResourceRelease(pMHLResource);
8494 }
8495 
8496 //**************************************************************************
8497 //  [Function Name]:
8498 //                  mdrv_mhl_AdjustSettingIControl()
8499 //  [Description]
8500 //
8501 //  [Arguments]:
8502 //
8503 //  [Return]:
8504 //
8505 //**************************************************************************
mdrv_mhl_AdjustSettingIControl(void * pInstance,MS_U8 ucIControl)8506 void mdrv_mhl_AdjustSettingIControl(void* pInstance, MS_U8 ucIControl)
8507 {
8508     void* pModule = NULL;
8509     void* pMHLResource = NULL;
8510     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
8511 
8512     UtopiaInstanceGetModule(pInstance, &pModule);
8513 
8514     if(UtopiaResourceObtain(pModule, MHL_POOL, &pMHLResource) != UTOPIA_STATUS_SUCCESS)
8515     {
8516         MDRV_MHL_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
8517     }
8518     else if(UtopiaResourceGetPrivate(pMHLResource, (void*)&pMHLResourcePrivate) != UTOPIA_STATUS_SUCCESS)
8519     {
8520         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
8521     }
8522     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
8523     {
8524         pMHLResourcePrivate->stSignalStatusInfo.ucIControlValue = ucIControl;
8525     }
8526 
8527     UtopiaResourceRelease(pMHLResource);
8528 }
8529 
8530 //**************************************************************************
8531 //  [Function Name]:
8532 //                  mdrv_mhl_AdjustImpedanceSetting()
8533 //  [Description]
8534 //
8535 //  [Arguments]:
8536 //
8537 //  [Return]:
8538 //
8539 //**************************************************************************
mdrv_mhl_AdjustImpedanceSetting(void * pInstance,MS_U8 ucImpedance)8540 void mdrv_mhl_AdjustImpedanceSetting(void* pInstance, MS_U8 ucImpedance)
8541 {
8542     void* pModule = NULL;
8543     void* pMHLResource = NULL;
8544     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
8545 
8546     UtopiaInstanceGetModule(pInstance, &pModule);
8547 
8548     if(UtopiaResourceObtain(pModule, MHL_POOL, &pMHLResource) != UTOPIA_STATUS_SUCCESS)
8549     {
8550         MDRV_MHL_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
8551     }
8552     else if(UtopiaResourceGetPrivate(pMHLResource, (void*)&pMHLResourcePrivate) != UTOPIA_STATUS_SUCCESS)
8553     {
8554         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
8555     }
8556     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
8557     {
8558         pMHLResourcePrivate->stSignalStatusInfo.ucImpedanceOffset = ucImpedance;
8559     }
8560 
8561     UtopiaResourceRelease(pMHLResource);
8562 }
8563 
8564 //**************************************************************************
8565 //  [Function Name]:
8566 //                  mdrv_mhl_GetCableDetectFlag()
8567 //  [Description]
8568 //
8569 //  [Arguments]:
8570 //
8571 //  [Return]:
8572 //
8573 //**************************************************************************
mdrv_mhl_GetCableDetectFlag(void * pInstance)8574 MS_BOOL mdrv_mhl_GetCableDetectFlag(void* pInstance)
8575 {
8576     void* pModule = NULL;
8577     void* pMHLResource = NULL;
8578     MS_BOOL bStatusFlag = FALSE;
8579     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
8580 
8581     UtopiaInstanceGetModule(pInstance, &pModule);
8582 
8583     if(UtopiaResourceObtain(pModule, MHL_POOL, &pMHLResource) != UTOPIA_STATUS_SUCCESS)
8584     {
8585         MDRV_MHL_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
8586     }
8587     else if(UtopiaResourceGetPrivate(pMHLResource, (void*)&pMHLResourcePrivate) != UTOPIA_STATUS_SUCCESS)
8588     {
8589         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
8590     }
8591     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
8592     {
8593         bStatusFlag = GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CABLE_PLUG_FLAG);
8594     }
8595 
8596     UtopiaResourceRelease(pMHLResource);
8597 
8598     return bStatusFlag;
8599 }
8600 
8601 //**************************************************************************
8602 //  [Function Name]:
8603 //                  mdrv_mhl_GetCbusConnectFlag()
8604 //  [Description]
8605 //
8606 //  [Arguments]:
8607 //
8608 //  [Return]:
8609 //
8610 //**************************************************************************
mdrv_mhl_GetCbusConnectFlag(void * pInstance)8611 MS_BOOL mdrv_mhl_GetCbusConnectFlag(void* pInstance)
8612 {
8613     void* pModule = NULL;
8614     void* pMHLResource = NULL;
8615     MS_BOOL bStatusFlag = FALSE;
8616     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
8617 
8618     UtopiaInstanceGetModule(pInstance, &pModule);
8619 
8620     if(UtopiaResourceObtain(pModule, MHL_POOL, &pMHLResource) != UTOPIA_STATUS_SUCCESS)
8621     {
8622         MDRV_MHL_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
8623     }
8624     else if(UtopiaResourceGetPrivate(pMHLResource, (void*)&pMHLResourcePrivate) != UTOPIA_STATUS_SUCCESS)
8625     {
8626         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
8627     }
8628     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
8629     {
8630         bStatusFlag = GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CBUS_CONNECT_FLAG);
8631     }
8632 
8633     UtopiaResourceRelease(pMHLResource);
8634 
8635     return bStatusFlag;
8636 }
8637 
8638 //**************************************************************************
8639 //  [Function Name]:
8640 //                  mdrv_mhl_CbusWakeupIntFlag()
8641 //  [Description]
8642 //
8643 //  [Arguments]:
8644 //
8645 //  [Return]:
8646 //
8647 //**************************************************************************
mdrv_mhl_CbusWakeupIntFlag(void * pInstance)8648 MS_BOOL mdrv_mhl_CbusWakeupIntFlag(void* pInstance)
8649 {
8650     void* pModule = NULL;
8651     void* pMHLResource = NULL;
8652     MS_BOOL bStatusFlag = FALSE;
8653     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
8654 
8655     UtopiaInstanceGetModule(pInstance, &pModule);
8656 
8657     if(UtopiaResourceObtain(pModule, MHL_POOL, &pMHLResource) != UTOPIA_STATUS_SUCCESS)
8658     {
8659         MDRV_MHL_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
8660     }
8661     else if(UtopiaResourceGetPrivate(pMHLResource, (void*)&pMHLResourcePrivate) != UTOPIA_STATUS_SUCCESS)
8662     {
8663         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
8664     }
8665     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
8666     {
8667         bStatusFlag = GET_MHL_RECEIVE_FLAG(pMHLResourcePrivate->ulCbusReceiveIndex, MHL_CBUS_RECEIVE_WAKE_FLAG);
8668     }
8669 
8670     UtopiaResourceRelease(pMHLResource);
8671 
8672     return bStatusFlag;
8673 }
8674 
8675 //**************************************************************************
8676 //  [Function Name]:
8677 //                  mdrv_mhl_SrcRCPSupportFlag()
8678 //  [Description]
8679 //
8680 //  [Arguments]:
8681 //
8682 //  [Return]:
8683 //
8684 //**************************************************************************
mdrv_mhl_SrcRCPSupportFlag(void * pInstance)8685 MS_BOOL mdrv_mhl_SrcRCPSupportFlag(void* pInstance)
8686 {
8687     void* pModule = NULL;
8688     void* pMHLResource = NULL;
8689     MS_BOOL bStatusFlag = FALSE;
8690     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
8691 
8692     UtopiaInstanceGetModule(pInstance, &pModule);
8693 
8694     if(UtopiaResourceObtain(pModule, MHL_POOL, &pMHLResource) != UTOPIA_STATUS_SUCCESS)
8695     {
8696         MDRV_MHL_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
8697     }
8698     else if(UtopiaResourceGetPrivate(pMHLResource, (void*)&pMHLResourcePrivate) != UTOPIA_STATUS_SUCCESS)
8699     {
8700         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
8701     }
8702     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
8703     {
8704         bStatusFlag = GET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_RCP_FUNCTION_FLAG);
8705     }
8706 
8707     UtopiaResourceRelease(pMHLResource);
8708 
8709     return bStatusFlag;
8710 }
8711 
8712 //**************************************************************************
8713 //  [Function Name]:
8714 //                  mdrv_mhl_SrcRAPSupportFlag()
8715 //  [Description]
8716 //
8717 //  [Arguments]:
8718 //
8719 //  [Return]:
8720 //
8721 //**************************************************************************
mdrv_mhl_SrcRAPSupportFlag(void * pInstance)8722 MS_BOOL mdrv_mhl_SrcRAPSupportFlag(void* pInstance)
8723 {
8724     void* pModule = NULL;
8725     void* pMHLResource = NULL;
8726     MS_BOOL bStatusFlag = FALSE;
8727     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
8728 
8729     UtopiaInstanceGetModule(pInstance, &pModule);
8730 
8731     if(UtopiaResourceObtain(pModule, MHL_POOL, &pMHLResource) != UTOPIA_STATUS_SUCCESS)
8732     {
8733         MDRV_MHL_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
8734     }
8735     else if(UtopiaResourceGetPrivate(pMHLResource, (void*)&pMHLResourcePrivate) != UTOPIA_STATUS_SUCCESS)
8736     {
8737         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
8738     }
8739     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
8740     {
8741         bStatusFlag = GET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_RAP_FUNCTION_FLAG);
8742     }
8743 
8744     UtopiaResourceRelease(pMHLResource);
8745 
8746     return bStatusFlag;
8747 }
8748 
8749 //**************************************************************************
8750 //  [Function Name]:
8751 //                  mdrv_mhl_CbusGetStatusFlag()
8752 //  [Description]
8753 //
8754 //  [Arguments]:
8755 //
8756 //  [Return]:
8757 //
8758 //**************************************************************************
mdrv_mhl_CbusGetStatusFlag(void * pInstance,MS_U8 ucState)8759 MS_BOOL mdrv_mhl_CbusGetStatusFlag(void* pInstance, MS_U8 ucState)
8760 {
8761     void* pModule = NULL;
8762     void* pMHLResource = NULL;
8763     MS_BOOL bStatusFlag = FALSE;
8764     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
8765 
8766     UtopiaInstanceGetModule(pInstance, &pModule);
8767 
8768     if(UtopiaResourceObtain(pModule, MHL_POOL, &pMHLResource) != UTOPIA_STATUS_SUCCESS)
8769     {
8770         MDRV_MHL_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
8771     }
8772     else if(UtopiaResourceGetPrivate(pMHLResource, (void*)&pMHLResourcePrivate) != UTOPIA_STATUS_SUCCESS)
8773     {
8774         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
8775     }
8776     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
8777     {
8778         switch(ucState)
8779         {
8780             case MHL_CBUS_STATUS_FLAG_CABLE_DETECT:
8781                 bStatusFlag = GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CABLE_PLUG_FLAG);
8782                 break;
8783 
8784             case MHL_CBUS_STATUS_FLAG_CBUS_CONNECT:
8785                 bStatusFlag = GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CBUS_CONNECT_FLAG);
8786                 break;
8787 
8788             case MHL_CBUS_STATUS_FLAG_PATH_EN:
8789                 break;
8790 
8791             case MHL_CBUS_STATUS_FLAG_RECEIVE_PATH_EN:
8792                 break;
8793 
8794             case MHL_CBUS_STATUS_FLAG_RECEIVE_MUTED:
8795                 break;
8796 
8797             case MHL_CBUS_STATUS_FLAG_COMMUNICATE_BUSY:
8798                 bStatusFlag = GET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_COMMUNICATE_BUSY_FLAG);
8799                 break;
8800 
8801             default:
8802 
8803                 break;
8804         };
8805     }
8806 
8807     UtopiaResourceRelease(pMHLResource);
8808 
8809     return bStatusFlag;
8810 }
8811 
8812 //**************************************************************************
8813 //  [Function Name]:
8814 //                  mdrv_mhl_SendRAPCommand
8815 //  [Description]
8816 //                  MHL Cbus MSC Send RAP Command
8817 //  [Arguments]:
8818 //
8819 //  [Return]:
8820 //                  TRUE: success
8821 //                  FALSE: fail
8822 //**************************************************************************
mdrv_mhl_SendRAPCommand(void * pInstance,MS_U8 ucKeyCode)8823 MS_BOOL mdrv_mhl_SendRAPCommand(void* pInstance, MS_U8 ucKeyCode)
8824 {
8825     void* pModule = NULL;
8826     void* pMHLResource = NULL;
8827     MS_BOOL bSendFlag = FALSE;
8828     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
8829 
8830     UtopiaInstanceGetModule(pInstance, &pModule);
8831 
8832     if(UtopiaResourceObtain(pModule, MHL_POOL, &pMHLResource) != UTOPIA_STATUS_SUCCESS)
8833     {
8834         MDRV_MHL_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
8835     }
8836     else if(UtopiaResourceGetPrivate(pMHLResource, (void*)&pMHLResourcePrivate) != UTOPIA_STATUS_SUCCESS)
8837     {
8838         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
8839     }
8840     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
8841     {
8842         bSendFlag = _mdrv_mhl_CbusSendSubMessage(pMHLResourcePrivate, MSC_MSG_RAP, ucKeyCode, TRUE);
8843     }
8844 
8845     UtopiaResourceRelease(pMHLResource);
8846 
8847     return bSendFlag;
8848 }
8849 
8850 //**************************************************************************
8851 //  [Function Name]:
8852 //                  mdrv_mhl_SendRCPAutoReleaseCmd
8853 //  [Description]
8854 //                  MHL Cbus MSC Send RCP Command
8855 //  [Arguments]:
8856 //
8857 //  [Return]:
8858 //                  TRUE: success
8859 //                  FALSE: fail
8860 //**************************************************************************
mdrv_mhl_SendRCPAutoReleaseCmd(void * pInstance,MS_U8 ucKeyCode)8861 MS_BOOL mdrv_mhl_SendRCPAutoReleaseCmd(void* pInstance, MS_U8 ucKeyCode)
8862 {
8863     void* pModule = NULL;
8864     void* pMHLResource = NULL;
8865     MS_BOOL bSendFlag = FALSE;
8866     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
8867 
8868     UtopiaInstanceGetModule(pInstance, &pModule);
8869 
8870     if(UtopiaResourceObtain(pModule, MHL_POOL, &pMHLResource) != UTOPIA_STATUS_SUCCESS)
8871     {
8872         MDRV_MHL_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
8873     }
8874     else if(UtopiaResourceGetPrivate(pMHLResource, (void*)&pMHLResourcePrivate) != UTOPIA_STATUS_SUCCESS)
8875     {
8876         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
8877     }
8878     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
8879     {
8880         if(pMHLResourcePrivate->ucPreRCPKeyCode != ucKeyCode) // Key change
8881         {
8882             if(!GET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_RCP_RELEASE_ENABLE_FLAG))
8883             {
8884                 bSendFlag = _mdrv_mhl_CbusSendSubMessage(pMHLResourcePrivate, MSC_MSG_RCP, ucKeyCode, TRUE);
8885             }
8886         }
8887         else
8888         {
8889             bSendFlag = _mdrv_mhl_CbusSendSubMessage(pMHLResourcePrivate, MSC_MSG_RCP, ucKeyCode, TRUE);
8890         }
8891 
8892         if(bSendFlag)
8893         {
8894             pMHLResourcePrivate->ucPreRCPKeyCode = ucKeyCode;
8895 
8896             _mdrv_mhl_SetCbusTimerEvent(pMHLResourcePrivate, MHL_TIMER_EVENT_RCP_AUTO_RELEASE, MHL_CBUS_RCP_RELEASE_TIME);
8897 
8898             SET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_RCP_RELEASE_ENABLE_FLAG);
8899         }
8900     }
8901 
8902     UtopiaResourceRelease(pMHLResource);
8903 
8904     return bSendFlag;
8905 }
8906 
8907 //**************************************************************************
8908 //  [Function Name]:
8909 //                  mdrv_mhl_SendUCPCommand
8910 //  [Description]
8911 //                  MHL Cbus MSC Send UCP Command
8912 //  [Arguments]:
8913 //
8914 //  [Return]:
8915 //                  TRUE: success
8916 //                  FALSE: fail
8917 //**************************************************************************
mdrv_mhl_SendUCPCommand(void * pInstance,MS_U8 ucKeyCode)8918 MS_BOOL mdrv_mhl_SendUCPCommand(void* pInstance, MS_U8 ucKeyCode)
8919 {
8920     void* pModule = NULL;
8921     void* pMHLResource = NULL;
8922     MS_BOOL bSendFlag = FALSE;
8923     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
8924 
8925     UtopiaInstanceGetModule(pInstance, &pModule);
8926 
8927     if(UtopiaResourceObtain(pModule, MHL_POOL, &pMHLResource) != UTOPIA_STATUS_SUCCESS)
8928     {
8929         MDRV_MHL_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
8930     }
8931     else if(UtopiaResourceGetPrivate(pMHLResource, (void*)&pMHLResourcePrivate) != UTOPIA_STATUS_SUCCESS)
8932     {
8933         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
8934     }
8935     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
8936     {
8937         bSendFlag = _mdrv_mhl_CbusSendSubMessage(pMHLResourcePrivate, MSC_MSG_UCP, ucKeyCode, TRUE);
8938     }
8939 
8940     UtopiaResourceRelease(pMHLResource);
8941 
8942     return bSendFlag;
8943 }
8944 
8945 //**************************************************************************
8946 //  [Function Name]:
8947 //                  mdrv_mhl_SendWriteBurst
8948 //  [Description]
8949 //
8950 //  [Arguments]:
8951 //
8952 //  [Return]:
8953 //                  TRUE: success
8954 //                  FALSE: fail
8955 //**************************************************************************
mdrv_mhl_SendWriteBurst(void * pInstance,MS_U8 ucAddr,MS_U8 ucLength,MS_U8 * ucData)8956 MS_BOOL mdrv_mhl_SendWriteBurst(void* pInstance, MS_U8 ucAddr, MS_U8 ucLength, MS_U8 *ucData)
8957 {
8958     void* pModule = NULL;
8959     void* pMHLResource = NULL;
8960     MS_BOOL bSendFlag = FALSE;
8961     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
8962 
8963     UtopiaInstanceGetModule(pInstance, &pModule);
8964 
8965     if(UtopiaResourceObtain(pModule, MHL_POOL, &pMHLResource) != UTOPIA_STATUS_SUCCESS)
8966     {
8967         MDRV_MHL_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
8968     }
8969     else if(UtopiaResourceGetPrivate(pMHLResource, (void*)&pMHLResourcePrivate) != UTOPIA_STATUS_SUCCESS)
8970     {
8971         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
8972     }
8973     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
8974     {
8975         bSendFlag = _mdrv_mhl_CbusSendWriteBurst(pMHLResourcePrivate, ucAddr, ucLength, ucData);
8976     }
8977 
8978     UtopiaResourceRelease(pMHLResource);
8979 
8980     return bSendFlag;
8981 }
8982 
8983 //**************************************************************************
8984 //  [Function Name]:
8985 //                  mdrv_mhl_CbusSendUserWriteBurst
8986 //  [Description]
8987 //
8988 //  [Arguments]:
8989 //
8990 //  [Return]:
8991 //                  TRUE: success
8992 //                  FALSE: fail
8993 //**************************************************************************
mdrv_mhl_CbusSendUserWriteBurst(void * pInstance,MS_U8 ucLength,MS_U8 * ucData)8994 MS_BOOL mdrv_mhl_CbusSendUserWriteBurst(void* pInstance, MS_U8 ucLength, MS_U8 *ucData)
8995 {
8996     void* pModule = NULL;
8997     void* pMHLResource = NULL;
8998     MS_BOOL bSendFlag = FALSE;
8999     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
9000 
9001     UtopiaInstanceGetModule(pInstance, &pModule);
9002 
9003     if(UtopiaResourceObtain(pModule, MHL_POOL, &pMHLResource) != UTOPIA_STATUS_SUCCESS)
9004     {
9005         MDRV_MHL_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
9006     }
9007     else if(UtopiaResourceGetPrivate(pMHLResource, (void*)&pMHLResourcePrivate) != UTOPIA_STATUS_SUCCESS)
9008     {
9009         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
9010     }
9011     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
9012     {
9013         if(GET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_USER_WRITE_BURST_FLAG))
9014         {
9015             if(pMHLResourcePrivate->ucWriteBurstState == MHL_CBUS_WRITE_BURST_REVEIVE_GRANT)
9016             {
9017                 if(_mdrv_mhl_CbusSendWriteBurst(pMHLResourcePrivate, 0x40, ucLength, ucData))
9018                 {
9019                     CLR_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_USER_WRITE_BURST_FLAG);
9020 
9021                     pMHLResourcePrivate->ucWriteBurstState = MHL_CBUS_WRITE_BURST_SEND_DATA;
9022 
9023                     bSendFlag = TRUE;
9024                 }
9025             }
9026         }
9027         else if(pMHLResourcePrivate->ucWriteBurstState == MHL_CBUS_WRITE_BURST_NONE)
9028         {
9029             SET_MHL_SEND_FLAG(pMHLResourcePrivate->ulCbusSendIndex, MHL_CBUS_SEND_USER_WRITE_BURST_FLAG);
9030         }
9031     }
9032 
9033     UtopiaResourceRelease(pMHLResource);
9034 
9035     return bSendFlag;
9036 }
9037 
9038 //**************************************************************************
9039 //  [Function Name]:
9040 //                  mdrv_mhl_GetDeviceCapability
9041 //  [Description]
9042 //
9043 //  [Arguments]:
9044 //
9045 //  [Return]:
9046 //
9047 //**************************************************************************
mdrv_mhl_GetDeviceCapability(void * pInstance,MS_U16 usDevcapMask,MS_U8 * ucDevcap)9048 MS_BOOL mdrv_mhl_GetDeviceCapability(void* pInstance, MS_U16 usDevcapMask, MS_U8 *ucDevcap)
9049 {
9050     void* pModule = NULL;
9051     void* pMHLResource = NULL;
9052     MS_BOOL bDoneFlag = FALSE;
9053     MS_U8 uctemp = 0;
9054     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
9055 
9056     UtopiaInstanceGetModule(pInstance, &pModule);
9057 
9058     if(UtopiaResourceObtain(pModule, MHL_POOL, &pMHLResource) != UTOPIA_STATUS_SUCCESS)
9059     {
9060         MDRV_MHL_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
9061     }
9062     else if(UtopiaResourceGetPrivate(pMHLResource, (void*)&pMHLResourcePrivate) != UTOPIA_STATUS_SUCCESS)
9063     {
9064         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
9065     }
9066     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
9067     {
9068         if(!GET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_READ_DEVCAP_FLAG))
9069         {
9070             pMHLResourcePrivate->usReadDevcapMask = usDevcapMask;
9071         }
9072 
9073         if(GET_MHL_DONE_FLAG(pMHLResourcePrivate->ucProcDoneIndex, MHL_READ_DEVCAP_DONE_FLAG))
9074         {
9075             if(ucDevcap != NULL)
9076             {
9077                 for(uctemp = 0; uctemp < MHL_DEVICE_CAPABILITY_SIZE; uctemp++)
9078                 {
9079                     if(usDevcapMask &BIT(uctemp))
9080                     {
9081                         ucDevcap[uctemp] = pMHLResourcePrivate->ucSourceDevcapTable[uctemp];
9082                     }
9083                     else
9084                     {
9085                         ucDevcap[uctemp] = 0;
9086                     }
9087                 }
9088             }
9089 
9090             bDoneFlag = TRUE;
9091         }
9092     }
9093 
9094     UtopiaResourceRelease(pMHLResource);
9095 
9096     return bDoneFlag;
9097 }
9098 
9099 //**************************************************************************
9100 //  [Function Name]:
9101 //                  mdrv_mhl_GetExtendDeviceCapability
9102 //  [Description]
9103 //
9104 //  [Arguments]:
9105 //
9106 //  [Return]:
9107 //
9108 //**************************************************************************
mdrv_mhl_GetExtendDeviceCapability(void * pInstance,MS_U16 usExtendDevcapMask,MS_U8 * ucExtendDevcap)9109 MS_BOOL mdrv_mhl_GetExtendDeviceCapability(void* pInstance, MS_U16 usExtendDevcapMask, MS_U8 *ucExtendDevcap)
9110 {
9111     void* pModule = NULL;
9112     void* pMHLResource = NULL;
9113     MS_BOOL bDoneFlag = FALSE;
9114     MS_U8 uctemp = 0;
9115     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
9116 
9117     UtopiaInstanceGetModule(pInstance, &pModule);
9118 
9119     if(UtopiaResourceObtain(pModule, MHL_POOL, &pMHLResource) != UTOPIA_STATUS_SUCCESS)
9120     {
9121         MDRV_MHL_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
9122     }
9123     else if(UtopiaResourceGetPrivate(pMHLResource, (void*)&pMHLResourcePrivate) != UTOPIA_STATUS_SUCCESS)
9124     {
9125         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
9126     }
9127     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
9128     {
9129         if(!GET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_READ_XDEVCAP_FLAG))
9130         {
9131             pMHLResourcePrivate->usReadExtendDevcapMask = usExtendDevcapMask;
9132         }
9133 
9134         if(GET_MHL_DONE_FLAG(pMHLResourcePrivate->ucProcDoneIndex, MHL_READ_XDEVCAP_DONE_FLAG))
9135         {
9136             if(ucExtendDevcap != NULL)
9137             {
9138                 for(uctemp = 0; uctemp < MHL_XDEVICE_CAPABILITY_SIZE; uctemp++)
9139                 {
9140                     if(usExtendDevcapMask &BIT(uctemp))
9141                     {
9142                         ucExtendDevcap[uctemp] = pMHLResourcePrivate->ucSourceDevcapTable[MHL_DEVICE_CAPABILITY_SIZE +uctemp];
9143                     }
9144                     else
9145                     {
9146                         ucExtendDevcap[uctemp] = 0;
9147                     }
9148                 }
9149             }
9150 
9151             bDoneFlag = TRUE;
9152         }
9153     }
9154 
9155     UtopiaResourceRelease(pMHLResource);
9156 
9157     return bDoneFlag;
9158 }
9159 
9160 //**************************************************************************
9161 //  [Function Name]:
9162 //                  mdrv_mhl_GetDeviceVenderID
9163 //  [Description]
9164 //
9165 //  [Arguments]:
9166 //
9167 //  [Return]:
9168 //
9169 //**************************************************************************
mdrv_mhl_GetDeviceVenderID(void * pInstance,MS_U8 * ucVenderID)9170 MS_BOOL mdrv_mhl_GetDeviceVenderID(void* pInstance, MS_U8 *ucVenderID)
9171 {
9172     void* pModule = NULL;
9173     void* pMHLResource = NULL;
9174     MS_BOOL bDoneFlag = FALSE;
9175     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
9176 
9177     UtopiaInstanceGetModule(pInstance, &pModule);
9178 
9179     if(UtopiaResourceObtain(pModule, MHL_POOL, &pMHLResource) != UTOPIA_STATUS_SUCCESS)
9180     {
9181         MDRV_MHL_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
9182     }
9183     else if(UtopiaResourceGetPrivate(pMHLResource, (void*)&pMHLResourcePrivate) != UTOPIA_STATUS_SUCCESS)
9184     {
9185         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
9186     }
9187     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
9188     {
9189         if(GET_MHL_DONE_FLAG(pMHLResourcePrivate->ucProcDoneIndex, MHL_GET_VENDER_ID_DONE_FLAG))
9190         {
9191             *ucVenderID = pMHLResourcePrivate->ucSourceVenderID;
9192 
9193             bDoneFlag = TRUE;
9194         }
9195         else
9196         {
9197             SET_MHL_ENABLE_FLAG(pMHLResourcePrivate->ulEnableIndex, MHL_ENABLE_GET_VENDER_ID_FLAG);
9198         }
9199     }
9200 
9201     UtopiaResourceRelease(pMHLResource);
9202 
9203     return bDoneFlag;
9204 }
9205 
9206 //**************************************************************************
9207 //  [Function Name]:
9208 //                  mdrv_mhl_GetWriteBurstData
9209 //  [Description]
9210 //
9211 //  [Arguments]:
9212 //
9213 //  [Return]:
9214 //
9215 //**************************************************************************
mdrv_mhl_GetWriteBurstData(void * pInstance,MS_U8 * ucData)9216 MS_BOOL mdrv_mhl_GetWriteBurstData(void* pInstance, MS_U8 *ucData)
9217 {
9218     void* pModule = NULL;
9219     void* pMHLResource = NULL;
9220     MS_BOOL bDoneFlag = FALSE;
9221     MS_U8 uctemp = 0;
9222     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
9223 
9224     UtopiaInstanceGetModule(pInstance, &pModule);
9225 
9226     if(UtopiaResourceObtain(pModule, MHL_POOL, &pMHLResource) != UTOPIA_STATUS_SUCCESS)
9227     {
9228         MDRV_MHL_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
9229     }
9230     else if(UtopiaResourceGetPrivate(pMHLResource, (void*)&pMHLResourcePrivate) != UTOPIA_STATUS_SUCCESS)
9231     {
9232         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
9233     }
9234     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
9235     {
9236         if(pMHLResourcePrivate->ucWriteBurstAddress > 0)
9237         {
9238             pMHLResourcePrivate->ucWriteBurstAddress = 0;
9239 
9240             for(uctemp = 0; uctemp < pMHLResourcePrivate->ucWriteBurstLength; uctemp++)
9241             {
9242                 ucData[uctemp] = pMHLResourcePrivate->ucWriteBurstInformation[uctemp];
9243             }
9244 
9245             bDoneFlag = TRUE;
9246         }
9247     }
9248 
9249     UtopiaResourceRelease(pMHLResource);
9250 
9251     return bDoneFlag;
9252 }
9253 
9254 //**************************************************************************
9255 //  [Function Name]:
9256 //                  mdrv_mhl_RegisterCallBackFunctions()
9257 //  [Description]
9258 //                  RCP &RAP call back
9259 //  [Arguments]:
9260 //
9261 //  [Return]:
9262 //
9263 //**************************************************************************
mdrv_mhl_RegisterCallBackFunctions(void * pInstance,MS_BOOL bRCPfunctionFlag,MS_BOOL bRAPfunctionFlag)9264 void mdrv_mhl_RegisterCallBackFunctions(void* pInstance, MS_BOOL bRCPfunctionFlag, MS_BOOL bRAPfunctionFlag)
9265 {
9266     void* pModule = NULL;
9267     void* pMHLResource = NULL;
9268     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
9269 
9270     UtopiaInstanceGetModule(pInstance, &pModule);
9271 
9272     if(UtopiaResourceObtain(pModule, MHL_POOL, &pMHLResource) != UTOPIA_STATUS_SUCCESS)
9273     {
9274         MDRV_MHL_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
9275     }
9276     else if(UtopiaResourceGetPrivate(pMHLResource, (void*)&pMHLResourcePrivate) != UTOPIA_STATUS_SUCCESS)
9277     {
9278         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
9279     }
9280     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
9281     {
9282         if(bRCPfunctionFlag)
9283         {
9284             SET_MHL_CALLBACK_FLAG(pMHLResourcePrivate->ucCallBackFunctionIndex, MHL_CALLBACK_RCP_FUNCTION_FLAG);
9285         }
9286 
9287         if(bRAPfunctionFlag)
9288         {
9289             SET_MHL_CALLBACK_FLAG(pMHLResourcePrivate->ucCallBackFunctionIndex, MHL_CALLBACK_RAP_FUNCTION_FLAG);
9290         }
9291     }
9292 
9293     UtopiaResourceRelease(pMHLResource);
9294 }
9295 
9296 //**************************************************************************
9297 //  [Function Name]:
9298 //                  mdrv_mhl_RegisterRcpCallBackFunction()
9299 //  [Description]
9300 //                  RCP call back
9301 //  [Arguments]:
9302 //
9303 //  [Return]:
9304 //
9305 //**************************************************************************
mdrv_mhl_RegisterRcpCallBackFunction(void * pInstance,MS_BOOL bRCPfunctionFlag)9306 void mdrv_mhl_RegisterRcpCallBackFunction(void* pInstance, MS_BOOL bRCPfunctionFlag)
9307 {
9308     void* pModule = NULL;
9309     void* pMHLResource = NULL;
9310     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
9311 
9312     UtopiaInstanceGetModule(pInstance, &pModule);
9313 
9314     if(UtopiaResourceObtain(pModule, MHL_POOL, &pMHLResource) != UTOPIA_STATUS_SUCCESS)
9315     {
9316         MDRV_MHL_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
9317     }
9318     else if(UtopiaResourceGetPrivate(pMHLResource, (void*)&pMHLResourcePrivate) != UTOPIA_STATUS_SUCCESS)
9319     {
9320         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
9321     }
9322     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
9323     {
9324         if(bRCPfunctionFlag)
9325         {
9326             SET_MHL_CALLBACK_FLAG(pMHLResourcePrivate->ucCallBackFunctionIndex, MHL_CALLBACK_RCP_FUNCTION_FLAG);
9327         }
9328     }
9329 
9330     UtopiaResourceRelease(pMHLResource);
9331 }
9332 
9333 //**************************************************************************
9334 //  [Function Name]:
9335 //                  mdrv_mhl_RegisterRapCallBackFunction()
9336 //  [Description]
9337 //                  RAP call back
9338 //  [Arguments]:
9339 //
9340 //  [Return]:
9341 //
9342 //**************************************************************************
mdrv_mhl_RegisterRapCallBackFunction(void * pInstance,MS_BOOL bRAPfunctionFlag)9343 void mdrv_mhl_RegisterRapCallBackFunction(void* pInstance, MS_BOOL bRAPfunctionFlag)
9344 {
9345     void* pModule = NULL;
9346     void* pMHLResource = NULL;
9347     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
9348 
9349     UtopiaInstanceGetModule(pInstance, &pModule);
9350 
9351     if(UtopiaResourceObtain(pModule, MHL_POOL, &pMHLResource) != UTOPIA_STATUS_SUCCESS)
9352     {
9353         MDRV_MHL_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
9354     }
9355     else if(UtopiaResourceGetPrivate(pMHLResource, (void*)&pMHLResourcePrivate) != UTOPIA_STATUS_SUCCESS)
9356     {
9357         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
9358     }
9359     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
9360     {
9361         if(bRAPfunctionFlag)
9362         {
9363             SET_MHL_CALLBACK_FLAG(pMHLResourcePrivate->ucCallBackFunctionIndex, MHL_CALLBACK_RAP_FUNCTION_FLAG);
9364         }
9365     }
9366 
9367     UtopiaResourceRelease(pMHLResource);
9368 }
9369 
9370 //**************************************************************************
9371 //  [Function Name]:
9372 //                  mdrv_mhl_RegisterUcpCallBackFunction()
9373 //  [Description]
9374 //                  UCP call back
9375 //  [Arguments]:
9376 //
9377 //  [Return]:
9378 //
9379 //**************************************************************************
mdrv_mhl_RegisterUcpCallBackFunction(void * pInstance,MS_BOOL bUCPfunctionFlag)9380 void mdrv_mhl_RegisterUcpCallBackFunction(void* pInstance, MS_BOOL bUCPfunctionFlag)
9381 {
9382     void* pModule = NULL;
9383     void* pMHLResource = NULL;
9384     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
9385 
9386     UtopiaInstanceGetModule(pInstance, &pModule);
9387 
9388     if(UtopiaResourceObtain(pModule, MHL_POOL, &pMHLResource) != UTOPIA_STATUS_SUCCESS)
9389     {
9390         MDRV_MHL_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
9391     }
9392     else if(UtopiaResourceGetPrivate(pMHLResource, (void*)&pMHLResourcePrivate) != UTOPIA_STATUS_SUCCESS)
9393     {
9394         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
9395     }
9396     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
9397     {
9398         if(bUCPfunctionFlag)
9399         {
9400             SET_MHL_CALLBACK_FLAG(pMHLResourcePrivate->ucCallBackFunctionIndex, MHL_CALLBACK_UCP_FUNCTION_FLAG);
9401         }
9402     }
9403 
9404     UtopiaResourceRelease(pMHLResource);
9405 }
9406 
9407 //**************************************************************************
9408 //  [Function Name]:
9409 //                  mdrv_mhl_RegisterAttCallBackFunction()
9410 //  [Description]
9411 //                  ATT call back
9412 //  [Arguments]:
9413 //
9414 //  [Return]:
9415 //
9416 //**************************************************************************
mdrv_mhl_RegisterAttCallBackFunction(void * pInstance,MS_BOOL bATTfunctionFlag)9417 void mdrv_mhl_RegisterAttCallBackFunction(void* pInstance, MS_BOOL bATTfunctionFlag)
9418 {
9419     void* pModule = NULL;
9420     void* pMHLResource = NULL;
9421     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
9422 
9423     UtopiaInstanceGetModule(pInstance, &pModule);
9424 
9425     if(UtopiaResourceObtain(pModule, MHL_POOL, &pMHLResource) != UTOPIA_STATUS_SUCCESS)
9426     {
9427         MDRV_MHL_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
9428     }
9429     else if(UtopiaResourceGetPrivate(pMHLResource, (void*)&pMHLResourcePrivate) != UTOPIA_STATUS_SUCCESS)
9430     {
9431         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
9432     }
9433     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
9434     {
9435         if(bATTfunctionFlag)
9436         {
9437             SET_MHL_CALLBACK_FLAG(pMHLResourcePrivate->ucCallBackFunctionIndex, MHL_CALLBACK_ATT_FUNCTION_FLAG);
9438         }
9439     }
9440 
9441     UtopiaResourceRelease(pMHLResource);
9442 }
9443 
9444 //**************************************************************************
9445 //  [Function Name]:
9446 //                  mdrv_mhl_RegisterRbpCallBackFunction()
9447 //  [Description]
9448 //                  RBP call back
9449 //  [Arguments]:
9450 //
9451 //  [Return]:
9452 //
9453 //**************************************************************************
mdrv_mhl_RegisterRbpCallBackFunction(void * pInstance,MS_BOOL bRBPfunctionFlag)9454 void mdrv_mhl_RegisterRbpCallBackFunction(void* pInstance, MS_BOOL bRBPfunctionFlag)
9455 {
9456     void* pModule = NULL;
9457     void* pMHLResource = NULL;
9458     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
9459 
9460     UtopiaInstanceGetModule(pInstance, &pModule);
9461 
9462     if(UtopiaResourceObtain(pModule, MHL_POOL, &pMHLResource) != UTOPIA_STATUS_SUCCESS)
9463     {
9464         MDRV_MHL_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
9465     }
9466     else if(UtopiaResourceGetPrivate(pMHLResource, (void*)&pMHLResourcePrivate) != UTOPIA_STATUS_SUCCESS)
9467     {
9468         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
9469     }
9470     else if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_GET_BASE_SUCCESS_FLAG))
9471     {
9472         if(bRBPfunctionFlag)
9473         {
9474             SET_MHL_CALLBACK_FLAG(pMHLResourcePrivate->ucCallBackFunctionIndex, MHL_CALLBACK_RBP_FUNCTION_FLAG);
9475         }
9476     }
9477 
9478     UtopiaResourceRelease(pMHLResource);
9479 }
9480 
9481 //**************************************************************************
9482 //  [Function Name]:
9483 //                  mdrv_mhl_GetConfiguration()
9484 //  [Description]
9485 //                  MHL get init config
9486 //  [Arguments]:
9487 //
9488 //  [Return]:
9489 //
9490 //**************************************************************************
mdrv_mhl_GetConfiguration(void * pInstance)9491 stMHL_INITIAL_CONFIG_INFO mdrv_mhl_GetConfiguration(void* pInstance)
9492 {
9493     void* pModule = NULL;
9494     void* pMHLResource = NULL;
9495     MS_U8 uctemp = 0;
9496     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
9497     stMHL_INITIAL_CONFIG_INFO stInitialConfigInfo = {0};
9498 
9499     stInitialConfigInfo.ulReturnValue = UTOPIA_STATUS_ERR_NOT_AVAIL;
9500 
9501     if(UtopiaResourceObtain(pModule, MHL_POOL, &pMHLResource) != UTOPIA_STATUS_SUCCESS)
9502     {
9503         MDRV_MHL_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
9504     }
9505     else if(UtopiaResourceGetPrivate(pMHLResource, (void*)&pMHLResourcePrivate) != UTOPIA_STATUS_SUCCESS)
9506     {
9507         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
9508     }
9509     else
9510     {
9511         if(_mdrv_mhl_InitRiuBase(pMHLResourcePrivate)) // Get base success
9512         {
9513             MDRV_MHL_MSG_INFO("** MHL get XC and PM base success \n");
9514         }
9515 
9516         if(GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_PREVENT_REINITIAL_FLAG))
9517         {
9518             stInitialConfigInfo.ulReturnValue = UTOPIA_STATUS_SUCCESS;
9519             stInitialConfigInfo.ucMHLSupportPath = pMHLResourcePrivate->ucMHLSupportPath;
9520 
9521             for(uctemp = 0; uctemp < (MHL_DEVICE_CAPABILITY_SIZE +MHL_XDEVICE_CAPABILITY_SIZE); uctemp++)
9522             {
9523                 stInitialConfigInfo.ucDeviceCapabilityTable[uctemp] = pMHLResourcePrivate->ucDeviceCapabilityTable[uctemp];
9524             }
9525         }
9526     }
9527 
9528     UtopiaResourceRelease(pMHLResource);
9529 
9530     return stInitialConfigInfo;
9531 }
9532 
9533 #ifdef CONFIG_UTOPIA_PROC_DBG_SUPPORT
9534 //**************************************************************************
9535 //  [Function Name]:
9536 //                  mdrv_mhl_MDCMDEchoCommand()
9537 //  [Description]
9538 //                  MHL MDCMD echo command function
9539 //  [Arguments]:
9540 //
9541 //  [Return]:
9542 //
9543 //**************************************************************************
mdrv_mhl_MDCMDEchoCommand(void * pInstance,MS_U64 * u64ReqHdl,char * pcCmdLine)9544 void mdrv_mhl_MDCMDEchoCommand(void* pInstance, MS_U64* u64ReqHdl, char* pcCmdLine)
9545 {
9546     char pch[] = "=,";
9547     char* psep;
9548 
9549     MdbPrint(u64ReqHdl, "LINE:%d, MDBCMD_CMDLINE\n", __LINE__);
9550     MdbPrint(u64ReqHdl, "pcCmdLine: %s\n", pcCmdLine);
9551 
9552     psep = strsep(&pcCmdLine, pch);
9553 
9554     if(strncmp("MHLOn", psep, 5) == 0)
9555     {
9556 
9557     }
9558 }
9559 
9560 //**************************************************************************
9561 //  [Function Name]:
9562 //                  mdrv_mhl_MDCMDGetInfo()
9563 //  [Description]
9564 //                  MHL MDCMD get info function
9565 //  [Arguments]:
9566 //
9567 //  [Return]:
9568 //
9569 //**************************************************************************
mdrv_mhl_MDCMDGetInfo(void * pInstance,MS_U64 * u64ReqHdl)9570 void mdrv_mhl_MDCMDGetInfo(void* pInstance, MS_U64* u64ReqHdl)
9571 {
9572     void* pModule = NULL;
9573     void* pMHLResource = NULL;
9574     MHL_RESOURCE_PRIVATE *pMHLResourcePrivate = NULL;
9575 
9576     if(UtopiaResourceObtain(pModule, MHL_POOL, &pMHLResource) != UTOPIA_STATUS_SUCCESS)
9577     {
9578         MDRV_MHL_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
9579     }
9580     else if(UtopiaResourceGetPrivate(pMHLResource, (void*)&pMHLResourcePrivate) != UTOPIA_STATUS_SUCCESS)
9581     {
9582         MDRV_MHL_MSG_ERROR("[%s,%5d] Get MHL resource failed\n", __FUNCTION__, __LINE__);
9583     }
9584     else
9585     {
9586         MdbPrint(u64ReqHdl, "LINE:%d, MDBCMD_GETINFO\n", __LINE__);
9587         MdbPrint(u64ReqHdl, "----------------  Mstar MHL Info -----------------\n");
9588         MdbPrint(u64ReqHdl, "Debug Cbus:\n");
9589         MdbPrint(u64ReqHdl, "Cable detect flag:    %d\n", GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CABLE_PLUG_FLAG));
9590         MdbPrint(u64ReqHdl, "Cbus connect flag:    %d\n", GET_MHL_SYSTEM_FLAG(pMHLResourcePrivate->ulSystemIndex, MHL_SYSTEM_CBUS_CONNECT_FLAG));
9591         MdbPrint(u64ReqHdl, "System index info:  0x%x\n", pMHLResourcePrivate->ulSystemIndex);
9592         MdbPrint(u64ReqHdl, "Timer index info:   0x%x\n", pMHLResourcePrivate->ulTimerIndex);
9593         MdbPrint(u64ReqHdl, "Enable index info:  0x%x\n", pMHLResourcePrivate->ulEnableIndex);
9594         MdbPrint(u64ReqHdl, "Cbus receive info:  0x%x\n", pMHLResourcePrivate->ulCbusReceiveIndex);
9595         MdbPrint(u64ReqHdl, "Cbus send info:     0x%x\n", pMHLResourcePrivate->ulCbusSendIndex);
9596         MdbPrint(u64ReqHdl, "Debug eCbus:\n");
9597         MdbPrint(u64ReqHdl, "eCbus state:          %d\n", pMHLResourcePrivate->ucECbusState);
9598         MdbPrint(u64ReqHdl, "Debug PHY:\n");
9599         MdbPrint(u64ReqHdl, "TMDS clock mode:      %d\n", pMHLResourcePrivate->ucTMDSClockMode);
9600         MdbPrint(u64ReqHdl, "Main link rate:       %d\n", pMHLResourcePrivate->stSignalStatusInfo.ucMainLinkRate);
9601         MdbPrint(u64ReqHdl, "Clock stable flag:    %d\n", pMHLResourcePrivate->stSignalStatusInfo.bClockStableFlag);
9602         MdbPrint(u64ReqHdl, "Signal stable flag:   %d\n", pMHLResourcePrivate->stSignalStatusInfo.bSignalStableFlag);
9603     }
9604 
9605     UtopiaResourceRelease(pMHLResource);
9606 }
9607 
9608 #endif
9609 
9610 #endif
9611 
9612 #endif // _MDRV_MHL_C_
9613