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 mhal_mhl.c
81 /// @author MStar Semiconductor Inc.
82 /// @brief MHL driver Function
83 ///////////////////////////////////////////////////////////////////////////////////////////////////
84
85 #ifndef _MHAL_MHL_C_
86 #define _MHAL_MHL_C_
87
88 //-------------------------------------------------------------------------------------------------
89 // Include Files
90 //-------------------------------------------------------------------------------------------------
91 // Common Definition
92 #include "MsCommon.h"
93 #include "MsVersion.h"
94 #ifdef MSOS_TYPE_LINUX_KERNEL
95 #include <linux/string.h>
96 #else
97 #include <string.h>
98 #endif
99 #include "MsIRQ.h"
100 #include "MsOS.h"
101 #include "mhal_xc_chip_config.h"
102 #include "mhl_hwreg_utility2.h"
103 #include "hwreg_pm_sleep.h"
104 #include "hwreg_hdmi.h"
105 #include "hwreg_hdcp.h"
106 #include "hwregMHL.h"
107 #include "mdrv_mhl_st.h"
108 #include "halMHL.h"
109
110 //-------------------------------------------------------------------------------------------------
111 // Local Defines
112 //-------------------------------------------------------------------------------------------------
113 #if(defined(CONFIG_MLOG))
114 #include "ULog.h"
115
116 #define MHAL_MHL_MSG_INFO(format, args...) ULOGI("MHL", format, ##args)
117 #define MHAL_MHL_MSG_WARNING(format, args...) ULOGW("MHL", format, ##args)
118 #define MHAL_MHL_MSG_DEBUG(format, args...) ULOGD("MHL", format, ##args)
119 #define MHAL_MHL_MSG_ERROR(format, args...) ULOGE("MHL", format, ##args)
120 #define MHAL_MHL_MSG_FATAL(format, args...) ULOGF("MHL", format, ##args)
121
122 #else
123 #define MHAL_MHL_MSG_INFO(format, args...) printf(format, ##args)
124 #define MHAL_MHL_MSG_WARNING(format, args...) printf(format, ##args)
125 #define MHAL_MHL_MSG_DEBUG(format, args...) printf(format, ##args)
126 #define MHAL_MHL_MSG_ERROR(format, args...) printf(format, ##args)
127 #define MHAL_MHL_MSG_FATAL(format, args...) printf(format, ##args)
128
129 #endif
130
131 #define MHL_DEBUG_SEND_MSC 0
132
133 #define DMHLInit 0
134
135 //-------------------------------------------------------------------------------------------------
136 // Local Structures
137 //-------------------------------------------------------------------------------------------------
138 typedef struct
139 {
140 MS_U32 addr;
141 MS_U16 mask;
142 MS_U16 databuf;
143 } msLoadTbl_S;
144
145 //-------------------------------------------------------------------------------------------------
146 // Global Variables
147 //-------------------------------------------------------------------------------------------------
148 MS_BOOL bMHLSignalStable = FALSE;
149 MS_BOOL bECbusEnableFlag = FALSE;
150 MS_U8 ucMHLSupportPort = E_MUX_NOT_SUPPORT_MHL;
151 MS_U8 ucIControlValue = MHL_ICONTROL_PD_VALUE;
152 MS_U8 ucImpedanceValue = MHL_IMPEDANCE_VALUE;
153 MS_U8 ucChipIDValue = MHL_CHIP_ID_MESSI;
154 MS_U8 ucECbusTrainState = MHL_ECBUS_STATE_DISABLE;
155 MS_U8 ucECbusTrainFailCount = 0;
156 MS_U8 ucMHL3LinkRate = MHL_AV_LINK_NONE;
157
158 //-------------------------------------------------------------------------------------------------
159 // MHL initial table
160 //-------------------------------------------------------------------------------------------------
161 static msLoadTbl_S tMHL_INITIAL_TABLE[] =
162 {
163 // Set accepted discover pulse high pulse width to ignore USB pulse
164 {REG_PM_MHL_CBUS_0C, BMASK(15:0), 0x0046}, // reject cbus discovery pulse below this limit
165 {REG_PM_MHL_CBUS_0D, BMASK(15:0), 0x0082}, // reject cbus discovery pulse above this limit
166 // CTS 4.3.7.1
167 {REG_MHL_CBUS_55, BMASK(7:4), BIT(4)}, // [7:4]: cbus requester transmit opportunity after arbitration
168 {REG_MHL_CBUS_70, BIT(14), BIT(14)}, // [14]: let edid current read initial address add 1
169
170 {REG_PM_MHL_CBUS_21, BIT(1), BIT(1)}, // [1]: output mhl_zxsense_tmds inv
171
172 // For CTS 6.3.10.7
173 {REG_MHL_CBUS_59, BMASK(15:0), 0xFBD0}, // timeout for a device receiving a packet within a command
174 {REG_MHL_CBUS_5A, BMASK(15:0), 0x0001}, // modify to 130ms
175
176 {REG_PM_MHL_CBUS_01, BMASK(5:2), 0}, // Not overwrite pull down resistor
177
178 #if(MHL_CBUS_OPERATION_MODE >= MHL_CBUS_HW_ISR_MODE)
179 {REG_MHL_CBUS_23, BMASK(10:8) |BIT(4), BIT(10) |BIT(4)}, // [10]: enable HW auto response read_devcap request
180 {REG_MHL_CBUS_6D, BMASK(11:0), BMASK(11:0)}, // Enable MHL HW mode
181 {REG_MHL_CBUS_71, BMASK(15:14)| BMASK(11:10), BMASK(15:14)| BMASK(11:10)},
182 {REG_MHL_CBUS_50, BIT(13), BIT(13)}, // [13]: MSC send command keep mode
183 #else
184 {REG_MHL_CBUS_23, BMASK(10:8) |BIT(4), 0}, // [10]: enable HW auto response read_devcap request
185 {REG_MHL_CBUS_6D, BMASK(11:0), 0}, // Enable MHL HW mode
186 {REG_MHL_CBUS_71, BMASK(15:14)| BMASK(11:10), 0},
187 {REG_MHL_CBUS_50, BIT(13), 0}, // [13]: MSC send command keep mode
188 #endif
189
190 #if(MHL_CBUS_OPERATION_MODE == MHL_CBUS_HW_REPLY_MODE)
191 {REG_MHL_CBUS_0B, BIT(14), BIT(14)}, // [14]: MSC send command keep mode
192 #endif
193
194 #if DMHL_INT_ENABLE
195 // Mask unused interrupt events
196 {REG_PM_MHL_CBUS_16, BIT(13)|BIT(9), BIT(13)|BIT(9)}, // [13]: lnk_lay_en_chg_int mask, [9]: conn_state_chg_int mask
197 {REG_PM_MHL_CBUS_18, BIT(9)|BIT(5)|BIT(1), BIT(9)|BIT(5)|BIT(1)}, // [9]: cbus_discover_pul_confirm_int mask, [5]: wakeup_pul_confirm_int mask, [1]: cbus_stuck_to_low_int mask.
198 {REG_PM_MHL_CBUS_30, BIT(1), BIT(1)}, // [1]: cbus conflict_int mask
199 {REG_PM_MHL_CBUS_38, BIT(13)|BIT(9)|BIT(5)|BIT(1), BIT(13)|BIT(9)|BIT(5)|BIT(1)}, // [13]: unused mask, [9]: unused mask, [5]: unused mask, [1]: unused mask.
200 {REG_MHL_CBUS_14, BIT(13), BIT(13)}, // [13]: int mask for monitor_sram_full
201 {REG_MHL_CBUS_18, BIT(13), BIT(13)}, // [13]: send rcv_pkt_ddc_sw_overwrite_err_in mask
202 {REG_MHL_CBUS_19, BIT(5)|BIT(1), BIT(5)|BIT(1)}, // [5]: send ddc send complete interrupt mask, [1]: send ddc error interrupt mask
203 {REG_MHL_CBUS_1B, BIT(1), BIT(1)}, // [1]: receive ddc packet valid mask
204 {REG_MHL_CBUS_1F, BIT(5)|BIT(1), BIT(5)|BIT(1)}, // [5]: ddc access edid timeout int mask, [1]: client_wrt_ddc_ram interrupt mask
205 {REG_MHL_CBUS_21, BIT(5), BIT(5)}, // [5]: ddc error interrupt mask
206 {REG_MHL_CBUS_22, BIT(9)|BIT(5)|BIT(1), BIT(9)|BIT(5)|BIT(1)}, // [9]: ddc access hdcp timeout int mask, [5]: receive nack pkt int_mask, [1]: receive abort pkt int mask
207 {REG_MHL_CBUS_23, BIT(13), BIT(13)}, // [13]: send rcv_pkt_msc_sw_overwrite_err_in mask
208 {REG_MHL_CBUS_24, BIT(1), BIT(1)}, // [1]: send error interrupt mask
209 {REG_MHL_CBUS_25, BIT(9)|BIT(5)|BIT(1), BIT(9)|BIT(5)|BIT(1)}, // [9]: response_pkt_msc_hw_int mask, [5]: snd_pkt_msc_hw_int mask, [1]: msc sw send complete interrupt mask
210 {REG_MHL_CBUS_63, BIT(9), BIT(9)}, // [9]: dytycycle_bad_int mask
211 {REG_MHL_CBUS_65, BIT(9)|BIT(5)|BIT(1), BIT(9)|BIT(5)|BIT(1)}, // [9]: rcv_parity_err_int mask, [5]: rcv_data_err_int mask, [1]: rcv_sync_err_int mask
212 {REG_MHL_CBUS_78, BIT(13)|BIT(9)|BIT(5)|BIT(1), BIT(13)|BIT(9)|BIT(5)|BIT(1)}, // [13]: unused mask, [9]: unused mask, [5]: unused mask, [1]: unused mask.
213 #endif
214 };
215
216 //-------------------------------------------------------------------------------------------------
217 // MHL power on table
218 //-------------------------------------------------------------------------------------------------
219 static msLoadTbl_S tMHL_POWER_ON_TABLE[] =
220 {
221 {REG_PM_MHL_CBUS_01, BMASK(5:2), 0}, // Not overwrite pull down resistor
222 };
223
224 //-------------------------------------------------------------------------------------------------
225 // MHL power down table
226 //-------------------------------------------------------------------------------------------------
227 static msLoadTbl_S tMHL_POWER_DOWN_TABLE[] =
228 {
229 {REG_PM_MHL_CBUS_01, BMASK(5:2), BIT(5)|BMASK(3:2)},
230 };
231
232 //-------------------------------------------------------------------------------------------------
233 // MHL power saving table
234 //-------------------------------------------------------------------------------------------------
235 static msLoadTbl_S tMHL_POWER_SAVING_TABLE[] =
236 {
237 {REG_PM_MHL_CBUS_01, BMASK(5:2), BIT(5)|BMASK(3:2)},
238 };
239
240 //-------------------------------------------------------------------------------------------------
241 // Local Functions
242 //-------------------------------------------------------------------------------------------------
243
244 //**************************************************************************
245 // [Function Name]:
246 // _mhal_mhl_IsCbusBusy()
247 // [Description]
248 //
249 // [Arguments]:
250 //
251 // [Return]:
252 //
253 //**************************************************************************
_mhal_mhl_IsCbusBusy(void)254 MS_BOOL _mhal_mhl_IsCbusBusy(void)
255 {
256 MS_BOOL bBusyFlag = FALSE;
257
258 if(!bECbusEnableFlag)
259 {
260 bBusyFlag = ((R2BYTE(REG_MHL_CBUS_5D) & 0x00F0) != 0 ? TRUE : FALSE);
261 }
262 return bBusyFlag;
263 }
264
265 //**************************************************************************
266 // [Function Name]:
267 // _mhal_mhl_HdmiBypassModeSetting()
268 // [Description]
269 // MHL HDMI bypass setting
270 // [Arguments]:
271 //
272 // [Return]:
273 //
274 //**************************************************************************
_mhal_mhl_HdmiBypassModeSetting(MS_U8 ucCbusSelect)275 void _mhal_mhl_HdmiBypassModeSetting(MS_U8 ucCbusSelect)
276 {
277 switch(ucCbusSelect)
278 {
279 #if(MHL_FUNCTION_SUPPORT_PORTA)
280 case MHL_CBUS_SELECT_PORTA:
281 if(GET_MHL_PATH_SUPPORT_PORTA())
282 {
283
284 }
285
286 break;
287 #endif
288
289 #if(MHL_FUNCTION_SUPPORT_PORTB)
290 case MHL_CBUS_SELECT_PORTB:
291 if(GET_MHL_PATH_SUPPORT_PORTB())
292 {
293 W2BYTEMSK(REG_DVI_DTOP_DUAL_P0_27_L, 0, BIT(6)| BIT(1)); // [6]: align, [1]: MHL pack-pixel mode
294 W2BYTEMSK(REG_COMBO_PHY0_P0_73_L, MHL_HDMI_EQ_SETTING_VALUE, BMASK(4:0)); // B channel EQ
295 W2BYTEMSK(REG_COMBO_PHY0_P0_5B_L, BIT(13)| BMASK(3:0), BIT(13)| BMASK(3:0));
296 W2BYTEMSK(REG_HDCP_DUAL_P0_09_L, 0, BIT(0)); // PP mode + HDCP eanble
297 W2BYTEMSK(REG_COMBO_PHY0_P0_45_L, (MHL_HDMI_LOCK_TIME_VALUE << 8), BMASK(14:8)); // Digital lock time value
298
299 if(ucImpedanceValue != MHL_IMPEDANCE_VALUE)
300 {
301 W2BYTEMSK(REG_COMBO_PHY0_P0_59_L, 0, BIT(8));
302 W2BYTEMSK(REG_COMBO_PHY0_P0_6B_L, (MHL_IMPEDANCE_VALUE << 12), BMASK(15:12));
303 }
304 }
305
306 break;
307 #endif
308
309 #if(MHL_FUNCTION_SUPPORT_PORTC)
310 case MHL_CBUS_SELECT_PORTC:
311 if(GET_MHL_PATH_SUPPORT_PORTC())
312 {
313 W2BYTEMSK(REG_DVI_DTOP_DUAL_P0_27_L, 0, BIT(6)| BIT(1)); // [6]: align, [1]: MHL pack-pixel mode
314 W2BYTEMSK(REG_COMBO_PHY0_P0_73_L, MHL_HDMI_EQ_SETTING_VALUE, BMASK(4:0)); // B channel EQ
315 W2BYTEMSK(REG_COMBO_PHY0_P0_5B_L, BIT(13)| BMASK(3:0), BIT(13)| BMASK(3:0));
316 W2BYTEMSK(REG_HDCP_DUAL_P0_09_L, 0, BIT(0)); // PP mode + HDCP eanble
317 W2BYTEMSK(REG_COMBO_PHY0_P0_45_L, (MHL_HDMI_LOCK_TIME_VALUE << 8), BMASK(14:8)); // Digital lock time value
318
319 if(ucImpedanceValue != MHL_IMPEDANCE_VALUE)
320 {
321 W2BYTEMSK(REG_COMBO_PHY0_P0_59_L, 0, BIT(8));
322 W2BYTEMSK(REG_COMBO_PHY0_P0_6B_L, (MHL_IMPEDANCE_VALUE << 12), BMASK(15:12));
323 }
324 }
325
326 break;
327 #endif
328
329 #if(MHL_FUNCTION_SUPPORT_PORTD)
330 case MHL_CBUS_SELECT_PORTD:
331 if(GET_MHL_PATH_SUPPORT_PORTD())
332 {
333
334 }
335
336 break;
337 #endif
338
339 default:
340
341 break;
342 };
343 }
344
345 //**************************************************************************
346 // [Function Name]:
347 // _mhal_mhl_Mhl24bitsModeSetting()
348 // [Description]
349 // MHL 24 bits mode setting
350 // [Arguments]:
351 //
352 // [Return]:
353 //
354 //**************************************************************************
_mhal_mhl_Mhl24bitsModeSetting(MS_U8 ucCbusSelect)355 void _mhal_mhl_Mhl24bitsModeSetting(MS_U8 ucCbusSelect)
356 {
357 switch(ucCbusSelect)
358 {
359 #if(MHL_FUNCTION_SUPPORT_PORTA)
360 case MHL_CBUS_SELECT_PORTA:
361 if(GET_MHL_PATH_SUPPORT_PORTA())
362 {
363
364 }
365
366 break;
367 #endif
368
369 #if(MHL_FUNCTION_SUPPORT_PORTB)
370 case MHL_CBUS_SELECT_PORTB:
371 if(GET_MHL_PATH_SUPPORT_PORTB())
372 {
373 W2BYTEMSK(REG_DVI_DTOP_DUAL_P0_27_L, BIT(6), BIT(6)| BIT(1)); // [6]: align, [1]: MHL pack-pixel mode
374 W2BYTEMSK(REG_COMBO_PHY0_P0_73_L, MHL_EQ_20_SETTING_VALUE, BMASK(4:0)); // B channel EQ
375 W2BYTEMSK(REG_COMBO_PHY0_P0_5B_L, 0, BIT(13)| BMASK(3:0));
376 W2BYTEMSK(REG_HDCP_DUAL_P0_09_L, 0, BIT(0)); // PP mode + HDCP eanble
377 W2BYTEMSK(REG_COMBO_PHY0_P0_45_L, (MHL_LOCK_TIME_VALUE << 8), BMASK(14:8)); // Digital lock time value
378
379 if(ucImpedanceValue != MHL_IMPEDANCE_VALUE)
380 {
381 W2BYTEMSK(REG_COMBO_PHY0_P0_59_L, BIT(8), BIT(8));
382 W2BYTEMSK(REG_COMBO_PHY0_P0_6B_L, (ucImpedanceValue << 12), BMASK(15:12));
383 }
384 }
385
386 break;
387 #endif
388
389 #if(MHL_FUNCTION_SUPPORT_PORTC)
390 case MHL_CBUS_SELECT_PORTC:
391 if(GET_MHL_PATH_SUPPORT_PORTC())
392 {
393 W2BYTEMSK(REG_DVI_DTOP_DUAL_P0_27_L, BIT(6), BIT(6)| BIT(1)); // [6]: align, [1]: MHL pack-pixel mode
394 W2BYTEMSK(REG_COMBO_PHY0_P0_73_L, MHL_EQ_20_SETTING_VALUE, BMASK(4:0)); // B channel EQ
395 W2BYTEMSK(REG_COMBO_PHY0_P0_5B_L, 0, BIT(13)| BMASK(3:0));
396 W2BYTEMSK(REG_HDCP_DUAL_P0_09_L, 0, BIT(0)); // PP mode + HDCP eanble
397 W2BYTEMSK(REG_COMBO_PHY0_P0_45_L, (MHL_LOCK_TIME_VALUE << 8), BMASK(14:8)); // Digital lock time value
398
399 if(ucImpedanceValue != MHL_IMPEDANCE_VALUE)
400 {
401 W2BYTEMSK(REG_COMBO_PHY0_P0_59_L, BIT(8), BIT(8));
402 W2BYTEMSK(REG_COMBO_PHY0_P0_6B_L, (ucImpedanceValue << 12), BMASK(15:12));
403 }
404 }
405
406 break;
407 #endif
408
409 #if(MHL_FUNCTION_SUPPORT_PORTD)
410 case MHL_CBUS_SELECT_PORTD:
411 if(GET_MHL_PATH_SUPPORT_PORTD())
412 {
413
414 }
415
416 break;
417 #endif
418
419 default:
420
421 break;
422 };
423 }
424
425 //**************************************************************************
426 // [Function Name]:
427 // _mhal_mhl_MhlPackedPixelModeSetting()
428 // [Description]
429 // MHL packed pixel mode setting
430 // [Arguments]:
431 //
432 // [Return]:
433 //
434 //**************************************************************************
_mhal_mhl_MhlPackedPixelModeSetting(MS_U8 ucCbusSelect)435 void _mhal_mhl_MhlPackedPixelModeSetting(MS_U8 ucCbusSelect)
436 {
437 switch(ucCbusSelect)
438 {
439 #if(MHL_FUNCTION_SUPPORT_PORTA)
440 case MHL_CBUS_SELECT_PORTA:
441 if(GET_MHL_PATH_SUPPORT_PORTA())
442 {
443
444 }
445
446 break;
447 #endif
448
449 #if(MHL_FUNCTION_SUPPORT_PORTB)
450 case MHL_CBUS_SELECT_PORTB:
451 if(GET_MHL_PATH_SUPPORT_PORTB())
452 {
453 W2BYTEMSK(REG_DVI_DTOP_DUAL_P0_27_L, BIT(1), BIT(1)); // [1]: MHL pack-pixel mode
454 W2BYTEMSK(REG_HDCP_DUAL_P0_09_L, BIT(0), BIT(0)); // PP mode + HDCP eanble
455 }
456
457 break;
458 #endif
459
460 #if(MHL_FUNCTION_SUPPORT_PORTC)
461 case MHL_CBUS_SELECT_PORTC:
462 if(GET_MHL_PATH_SUPPORT_PORTC())
463 {
464 W2BYTEMSK(REG_DVI_DTOP_DUAL_P0_27_L, BIT(1), BIT(1)); // [1]: MHL pack-pixel mode
465 W2BYTEMSK(REG_HDCP_DUAL_P0_09_L, BIT(0), BIT(0)); // PP mode + HDCP eanble
466 }
467
468 break;
469 #endif
470
471 #if(MHL_FUNCTION_SUPPORT_PORTD)
472 case MHL_CBUS_SELECT_PORTD:
473 if(GET_MHL_PATH_SUPPORT_PORTD())
474 {
475
476 }
477
478 break;
479 #endif
480
481 default:
482
483 break;
484 };
485 }
486
487 //**************************************************************************
488 // [Function Name]:
489 // _mhal_mhl_RxRtermControl()
490 // [Description]
491 // MHL TMDS termination resistor control
492 // [Arguments]:
493 //
494 // [Return]:
495 //
496 //**************************************************************************
_mhal_mhl_RxRtermControl(MS_U8 ucCbusSelect,RXRtermControl_T rctrl)497 void _mhal_mhl_RxRtermControl(MS_U8 ucCbusSelect, RXRtermControl_T rctrl)
498 {
499 switch(ucCbusSelect)
500 {
501 #if(MHL_FUNCTION_SUPPORT_PORTA)
502 case MHL_CBUS_SELECT_PORTA:
503 if(GET_MHL_PATH_SUPPORT_PORTA())
504 {
505 if (rctrl == RX_HDMI_RTERM)
506 {
507 W2BYTEMSK(REG_PM_MISC_63_L, 0, BMASK(2:0));// data R-term
508 W2BYTEMSK(REG_PM_MISC_63_L, 0, BIT(3));// clock R-term
509 }
510 else if (rctrl == RX_MHL_RTERM)
511 {
512 W2BYTEMSK(REG_PM_MISC_63_L, BIT(2), BMASK(2:0));// data R-term
513 W2BYTEMSK(REG_PM_MISC_63_L, 0, BIT(3));// clock R-term
514 }
515 else if (rctrl == RX_RTERM_OFF)
516 {
517 W2BYTEMSK(REG_PM_MISC_63_L, BMASK(2:0), BMASK(2:0));// data R-term
518 W2BYTEMSK(REG_PM_MISC_63_L, BIT(3), BIT(3));// clock R-term
519 }
520 }
521
522 break;
523 #endif
524
525 #if(MHL_FUNCTION_SUPPORT_PORTB)
526 case MHL_CBUS_SELECT_PORTB:
527 if(GET_MHL_PATH_SUPPORT_PORTB())
528 {
529 if (rctrl == RX_HDMI_RTERM)
530 {
531 W2BYTEMSK(REG_PM_MISC_63_L, 0, BMASK(6:4));// data R-term
532 W2BYTEMSK(REG_PM_MISC_63_L, 0, BIT(7));// clock R-term
533 }
534 else if (rctrl == RX_MHL_RTERM)
535 {
536 W2BYTEMSK(REG_PM_MISC_63_L, BIT(6), BMASK(6:4));// data R-term
537 W2BYTEMSK(REG_PM_MISC_63_L, 0, BIT(7));// clock R-term
538 }
539 else if (rctrl == RX_RTERM_OFF)
540 {
541 W2BYTEMSK(REG_PM_MISC_63_L, BMASK(6:4), BMASK(6:4));// data R-term
542 W2BYTEMSK(REG_PM_MISC_63_L, BIT(7), BIT(7));// clock R-term
543 }
544 }
545
546 break;
547 #endif
548
549 #if(MHL_FUNCTION_SUPPORT_PORTC)
550 case MHL_CBUS_SELECT_PORTC:
551 if(GET_MHL_PATH_SUPPORT_PORTC())
552 {
553 if (rctrl == RX_HDMI_RTERM)
554 {
555 W2BYTEMSK(REG_PM_MISC_63_L, 0, BMASK(10:8));// data R-term
556 W2BYTEMSK(REG_PM_MISC_63_L, 0, BIT(11));// clock R-term
557 }
558 else if (rctrl == RX_MHL_RTERM)
559 {
560 W2BYTEMSK(REG_PM_MISC_63_L, BIT(10), BMASK(10:8));// data R-term
561 W2BYTEMSK(REG_PM_MISC_63_L, 0, BIT(11));// clock R-term
562 }
563 else if (rctrl == RX_RTERM_OFF)
564 {
565 W2BYTEMSK(REG_PM_MISC_63_L, BMASK(10:8), BMASK(10:8));// data R-term
566 W2BYTEMSK(REG_PM_MISC_63_L, BIT(11), BIT(11));// clock R-term
567 }
568 }
569
570 break;
571 #endif
572
573 #if(MHL_FUNCTION_SUPPORT_PORTD)
574 case MHL_CBUS_SELECT_PORTD:
575 if(GET_MHL_PATH_SUPPORT_PORTD())
576 {
577 if (rctrl == RX_HDMI_RTERM)
578 {
579 W2BYTEMSK(REG_PM_MISC_63_L, 0, BMASK(14:12));// data R-term
580 W2BYTEMSK(REG_PM_MISC_63_L, 0, BIT(15));// clock R-term
581 }
582 else if (rctrl == RX_MHL_RTERM)
583 {
584 W2BYTEMSK(REG_PM_MISC_63_L, BIT(14), BMASK(14:12));// data R-term
585 W2BYTEMSK(REG_PM_MISC_63_L, 0, BIT(15));// clock R-term
586 }
587 else if (rctrl == RX_RTERM_OFF)
588 {
589 W2BYTEMSK(REG_PM_MISC_63_L, BMASK(14:12), BMASK(14:12));// data R-term
590 W2BYTEMSK(REG_PM_MISC_63_L, BIT(15), BIT(15));// clock R-term
591 }
592 }
593
594 break;
595 #endif
596
597 default:
598
599 break;
600 };
601 }
602
603 //**************************************************************************
604 // [Function Name]:
605 // _mhal_mhl_CbusForceToStandby()
606 // [Description]
607 //
608 // [Arguments]:
609 //
610 // [Return]:
611 //
612 //**************************************************************************
_mhal_mhl_CbusForceToStandby(void)613 void _mhal_mhl_CbusForceToStandby(void)
614 {
615 W2BYTEMSK(REG_MHL_CBUS_3A, BIT(4), BIT(4)); // clear received FIFO
616 W2BYTEMSK(REG_PM_MHL_CBUS_17, BIT(15), BIT(15)); // force enter PM mode
617 }
618
619 //**************************************************************************
620 // [Function Name]:
621 // _mhal_mhl_MHLForceToAttach()
622 // [Description]:
623 //
624 // [Arguments]:
625 //
626 // [Return]:
627 //
628 //**************************************************************************
_mhal_mhl_MHLForceToAttach(void)629 void _mhal_mhl_MHLForceToAttach(void)
630 {
631 W2BYTEMSK(REG_PM_MHL_CBUS_17, BIT(14), BIT(14));
632 }
633
634 #if(DMHL_LG_PRADA_PATCH)
635 //**************************************************************************
636 // [Function Name]:
637 // _mhal_mhl_AdjustCommonModeResistor()
638 // [Description]:
639 //
640 // [Arguments]:
641 //
642 // [Return]:
643 //
644 //**************************************************************************
_mhal_mhl_AdjustCommonModeResistor(MS_U8 ucCbusSelect,MS_BOOL bflag)645 void _mhal_mhl_AdjustCommonModeResistor(MS_U8 ucCbusSelect, MS_BOOL bflag)
646 {
647 switch(ucCbusSelect)
648 {
649 #if(MHL_FUNCTION_SUPPORT_PORTA)
650 case MHL_CBUS_SELECT_PORTA:
651 if(GET_MHL_PATH_SUPPORT_PORTA())
652 {
653
654 }
655
656 break;
657 #endif
658
659 #if(MHL_FUNCTION_SUPPORT_PORTB)
660 case MHL_CBUS_SELECT_PORTB:
661 if(GET_MHL_PATH_SUPPORT_PORTB())
662 {
663 W2BYTEMSK(REG_DVI_DTOP_DUAL_P0_27_L, bflag ? 0 : BIT(0), BIT(0)); // [0]: MHL mac enable
664 }
665
666 break;
667 #endif
668
669 #if(MHL_FUNCTION_SUPPORT_PORTC)
670 case MHL_CBUS_SELECT_PORTC:
671 if(GET_MHL_PATH_SUPPORT_PORTC())
672 {
673 W2BYTEMSK(REG_DVI_DTOP_DUAL_P0_27_L, bflag ? 0 : BIT(0), BIT(0)); // [0]: MHL mac enable
674 }
675
676 break;
677 #endif
678
679 #if(MHL_FUNCTION_SUPPORT_PORTD)
680 case MHL_CBUS_SELECT_PORTD:
681 if(GET_MHL_PATH_SUPPORT_PORTD())
682 {
683
684 }
685
686 break;
687 #endif
688
689 default:
690
691 break;
692 };
693 }
694
695 #endif
696
697 //**************************************************************************
698 // [Function Name]:
699 // _mhal_mhl_ClockBigChangeFlag()
700 // [Description]:
701 //
702 // [Arguments]:
703 //
704 // [Return]:
705 //
706 //**************************************************************************
_mhal_mhl_ClockBigChangeFlag(MS_U8 ucCbusSelect)707 MS_BOOL _mhal_mhl_ClockBigChangeFlag(MS_U8 ucCbusSelect)
708 {
709 MS_BOOL bindex = FALSE;
710
711 switch(ucCbusSelect)
712 {
713 #if(MHL_FUNCTION_SUPPORT_PORTA)
714 case MHL_CBUS_SELECT_PORTA:
715 if(GET_MHL_PATH_SUPPORT_PORTA())
716 {
717
718 }
719
720 break;
721 #endif
722
723 #if(MHL_FUNCTION_SUPPORT_PORTB)
724 case MHL_CBUS_SELECT_PORTB:
725 if(GET_MHL_PATH_SUPPORT_PORTB())
726 {
727
728 }
729
730 break;
731 #endif
732
733 #if(MHL_FUNCTION_SUPPORT_PORTC)
734 case MHL_CBUS_SELECT_PORTC:
735 if(GET_MHL_PATH_SUPPORT_PORTC())
736 {
737
738 }
739
740 break;
741 #endif
742
743 #if(MHL_FUNCTION_SUPPORT_PORTD)
744 case MHL_CBUS_SELECT_PORTD:
745 if(GET_MHL_PATH_SUPPORT_PORTD())
746 {
747
748 }
749
750 break;
751 #endif
752
753 default:
754
755 break;
756 };
757
758 return bindex;
759 }
760
761 //**************************************************************************
762 // [Function Name]:
763 // _mhal_mhl_CheckClockStatus()
764 // [Description]:
765 //
766 // [Arguments]:
767 //
768 // [Return]:
769 //
770 //**************************************************************************
_mhal_mhl_CheckClockStatus(MS_U8 ucCbusSelect)771 MS_U8 _mhal_mhl_CheckClockStatus(MS_U8 ucCbusSelect)
772 {
773 MS_BOOL bStable = FALSE;
774 MS_U16 usClkCount = 0;
775
776 switch(ucCbusSelect)
777 {
778 #if(MHL_FUNCTION_SUPPORT_PORTA)
779 case MHL_CBUS_SELECT_PORTA:
780 if(GET_MHL_PATH_SUPPORT_PORTA())
781 {
782
783 }
784
785 break;
786 #endif
787
788 #if(MHL_FUNCTION_SUPPORT_PORTB)
789 case MHL_CBUS_SELECT_PORTB:
790 if(GET_MHL_PATH_SUPPORT_PORTB())
791 {
792 usClkCount = R2BYTE(REG_COMBO_PHY0_P0_3C_L) & 0x0FFF;
793
794 if((R2BYTE(REG_COMBO_PHY0_P0_41_L) &BIT(9)) == BIT(9))
795 {
796 bStable = TRUE;
797
798 if((usClkCount < CBUS_CLOCK_DETECT_LEVEL) || _mhal_mhl_ClockBigChangeFlag(ucCbusSelect))
799 {
800 bStable = FALSE;
801 }
802 }
803 }
804
805 break;
806 #endif
807
808 #if(MHL_FUNCTION_SUPPORT_PORTC)
809 case MHL_CBUS_SELECT_PORTC:
810 if(GET_MHL_PATH_SUPPORT_PORTC())
811 {
812 usClkCount = R2BYTE(REG_COMBO_PHY0_P0_3C_L) & 0x0FFF;
813
814 if((R2BYTE(REG_COMBO_PHY0_P0_41_L) &BIT(9)) == BIT(9))
815 {
816 bStable = TRUE;
817
818 if((usClkCount < CBUS_CLOCK_DETECT_LEVEL) || _mhal_mhl_ClockBigChangeFlag(ucCbusSelect))
819 {
820 bStable = FALSE;
821 }
822 }
823 }
824
825 break;
826 #endif
827
828 #if(MHL_FUNCTION_SUPPORT_PORTD)
829 case MHL_CBUS_SELECT_PORTD:
830 if(GET_MHL_PATH_SUPPORT_PORTD())
831 {
832
833 }
834
835 break;
836 #endif
837
838 default:
839
840 break;
841 };
842
843 usClkCount = 0;
844
845 return bStable;
846 }
847
848 //**************************************************************************
849 // [Function Name]:
850 // _mhal_mhl_RtermHWControl()
851 // [Description]
852 //
853 // [Arguments]:
854 //
855 // [Return]:
856 //
857 //**************************************************************************
_mhal_mhl_RtermHWControl(MS_U8 ucCbusSelect,MS_BOOL bFlag)858 void _mhal_mhl_RtermHWControl(MS_U8 ucCbusSelect, MS_BOOL bFlag)
859 {
860 switch(ucCbusSelect)
861 {
862 #if(MHL_FUNCTION_SUPPORT_PORTA)
863 case MHL_CBUS_SELECT_PORTA:
864 if(GET_MHL_PATH_SUPPORT_PORTA())
865 {
866 W2BYTEMSK(REG_PM_MISC_61_L, bFlag? BIT(8): 0, BIT(8));
867 }
868
869 break;
870 #endif
871
872 #if(MHL_FUNCTION_SUPPORT_PORTB)
873 case MHL_CBUS_SELECT_PORTB:
874 if(GET_MHL_PATH_SUPPORT_PORTB())
875 {
876 W2BYTEMSK(REG_PM_MISC_61_L, bFlag? BIT(9): 0, BIT(9));
877 }
878
879 break;
880 #endif
881
882 #if(MHL_FUNCTION_SUPPORT_PORTC)
883 case MHL_CBUS_SELECT_PORTC:
884 if(GET_MHL_PATH_SUPPORT_PORTC())
885 {
886 W2BYTEMSK(REG_PM_MISC_61_L, bFlag? BIT(10): 0, BIT(10));
887 }
888
889 break;
890 #endif
891
892 #if(MHL_FUNCTION_SUPPORT_PORTD)
893 case MHL_CBUS_SELECT_PORTD:
894 if(GET_MHL_PATH_SUPPORT_PORTD())
895 {
896 W2BYTEMSK(REG_PM_MISC_61_L, bFlag? BIT(11): 0, BIT(11));
897 }
898
899 break;
900 #endif
901
902 default:
903
904 break;
905 };
906 }
907
908 //**************************************************************************
909 // [Function Name]:
910 // _mhal_mhl_ForcePullDown100K()
911 // [Description]
912 //
913 // [Arguments]:
914 //
915 // [Return]:
916 //
917 //**************************************************************************
_mhal_mhl_ForcePullDown100K(MS_BOOL bEnable)918 void _mhal_mhl_ForcePullDown100K(MS_BOOL bEnable)
919 {
920 W2BYTEMSK(REG_PM_MHL_CBUS_20, bEnable? BIT(7): 0, BIT(7));
921 }
922
923 //**************************************************************************
924 // [Function Name]:
925 // _mhal_mhl_GetEMSCOneByteCRC()
926 // [Description]
927 //
928 // [Arguments]:
929 //
930 // [Return]:
931 //
932 //**************************************************************************
_mhal_mhl_GetEMSCOneByteCRC(MS_U8 ucOpCode)933 MS_U8 _mhal_mhl_GetEMSCOneByteCRC(MS_U8 ucOpCode)
934 {
935 MS_U8 ucAValue = 0;
936 MS_U8 ucBValue = 0;
937 MS_U8 ucCommand = BIT(7) |BIT(6) |((ucOpCode &BMASK(2:0)) << 2);
938
939 ucAValue = GET_BIT(ucCommand &BIT(7)) +GET_BIT(ucCommand &BIT(5)) +GET_BIT(ucCommand &BIT(3)) +2;
940 ucBValue = GET_BIT(ucCommand &BIT(6)) +GET_BIT(ucCommand &BIT(4)) +GET_BIT(ucCommand &BIT(2)) +2;
941
942 if(ucAValue &BIT(0))
943 {
944 ucCommand |= BIT(1);
945 }
946
947 if(ucBValue &BIT(0))
948 {
949 ucCommand |= BIT(0);
950 }
951
952 return ucCommand;
953 }
954
955 //**************************************************************************
956 // [Function Name]:
957 // _mhal_mhl_GetEMSCTwoByteCRC()
958 // [Description]
959 //
960 // [Arguments]:
961 //
962 // [Return]:
963 //
964 //**************************************************************************
_mhal_mhl_GetEMSCTwoByteCRC(MS_U8 ucOpCode,MS_U8 ucValue)965 MS_U8 _mhal_mhl_GetEMSCTwoByteCRC(MS_U8 ucOpCode, MS_U8 ucValue)
966 {
967 MS_U8 ucAValue = 0;
968 MS_U8 ucBValue = 0;
969 MS_U8 ucCValue = 0;
970 MS_U16 ucCommand = BIT(13) |(((MS_U16)ucOpCode &BMASK(1:0)) << 11) |(((MS_U16)ucValue &BMASK(7:0)) << 3);
971
972 ucAValue = GET_BIT(ucCommand &BIT(15)) +GET_BIT(ucCommand &BIT(13)) +GET_BIT(ucCommand &BIT(12)) +GET_BIT(ucCommand &BIT(11)) +GET_BIT(ucCommand &BIT(8));
973 ucAValue = ucAValue +GET_BIT(ucCommand &BIT(6)) +GET_BIT(ucCommand &BIT(5)) +GET_BIT(ucCommand &BIT(4)) +3;
974 ucBValue = GET_BIT(ucCommand &BIT(15)) +GET_BIT(ucCommand &BIT(14)) +GET_BIT(ucCommand &BIT(13)) +GET_BIT(ucCommand &BIT(10)) +GET_BIT(ucCommand &BIT(8));
975 ucBValue = ucBValue +GET_BIT(ucCommand &BIT(7)) +GET_BIT(ucCommand &BIT(6)) +GET_BIT(ucCommand &BIT(3)) +2;
976 ucCValue = GET_BIT(ucCommand &BIT(14)) +GET_BIT(ucCommand &BIT(13)) +GET_BIT(ucCommand &BIT(12)) +GET_BIT(ucCommand &BIT(9)) +GET_BIT(ucCommand &BIT(7));
977 ucCValue = ucCValue +GET_BIT(ucCommand &BIT(6)) +GET_BIT(ucCommand &BIT(5)) +2;
978
979 if(ucAValue &BIT(0))
980 {
981 ucCommand |= BIT(2);
982 }
983
984 if(ucBValue &BIT(0))
985 {
986 ucCommand |= BIT(1);
987 }
988
989 if(ucCValue &BIT(0))
990 {
991 ucCommand |= BIT(0);
992 }
993
994 return (ucCommand &BMASK(7:0));
995 }
996
997 //**************************************************************************
998 // [Function Name]:
999 // _mhal_mhl_GetEMSCPayloadCRC()
1000 // [Description]
1001 //
1002 // [Arguments]:
1003 //
1004 // [Return]:
1005 //
1006 //**************************************************************************
_mhal_mhl_GetEMSCPayloadCRC(MS_U8 ucOpCode,MS_U16 usCRCValus)1007 MS_U16 _mhal_mhl_GetEMSCPayloadCRC(MS_U8 ucOpCode, MS_U16 usCRCValus)
1008 {
1009 MS_U8 ucAValue = 0;
1010 MS_U8 ucBValue = 0;
1011 MS_U8 ucCValue = GET_BIT(ucOpCode &BIT(7)) +GET_BIT(ucOpCode &BIT(6)) +GET_BIT(usCRCValus &BIT(6)) +GET_BIT(usCRCValus &BIT(7));
1012 MS_U8 ucDValue = GET_BIT(ucOpCode &BIT(6)) +GET_BIT(ucOpCode &BIT(5)) +GET_BIT(usCRCValus &BIT(5)) +GET_BIT(usCRCValus &BIT(6));
1013 MS_U8 ucEValue = GET_BIT(ucOpCode &BIT(5)) +GET_BIT(ucOpCode &BIT(4)) +GET_BIT(usCRCValus &BIT(4)) +GET_BIT(usCRCValus &BIT(5));
1014 MS_U8 ucFValue = GET_BIT(ucOpCode &BIT(4)) +GET_BIT(ucOpCode &BIT(3)) +GET_BIT(usCRCValus &BIT(3)) +GET_BIT(usCRCValus &BIT(4));
1015 MS_U8 ucGValue = GET_BIT(ucOpCode &BIT(3)) +GET_BIT(ucOpCode &BIT(2)) +GET_BIT(usCRCValus &BIT(2)) +GET_BIT(usCRCValus &BIT(3));
1016 MS_U8 ucHValue = GET_BIT(ucOpCode &BIT(2)) +GET_BIT(ucOpCode &BIT(1)) +GET_BIT(usCRCValus &BIT(1)) +GET_BIT(usCRCValus &BIT(2));
1017 MS_U8 ucIValue = GET_BIT(ucOpCode &BIT(1)) +GET_BIT(ucOpCode &BIT(0)) +GET_BIT(usCRCValus &BIT(0)) +GET_BIT(usCRCValus &BIT(1)) +GET_BIT(usCRCValus &BIT(15));
1018 MS_U8 ucJValue = GET_BIT(ucOpCode &BIT(0)) +GET_BIT(usCRCValus &BIT(0)) +GET_BIT(usCRCValus &BIT(14));
1019 MS_U8 ucKValue = GET_BIT(usCRCValus &BIT(13));
1020 MS_U8 ucLValue = GET_BIT(usCRCValus &BIT(12));
1021 MS_U8 ucMValue = GET_BIT(usCRCValus &BIT(11));
1022 MS_U8 ucNValue = GET_BIT(usCRCValus &BIT(10));
1023 MS_U8 ucOValue = GET_BIT(usCRCValus &BIT(9));
1024 MS_U8 ucPValue = 0;
1025 MS_U16 usCommand = 0;
1026
1027 ucAValue = GET_BIT(ucOpCode &BIT(7)) +GET_BIT(ucOpCode &BIT(6)) +GET_BIT(ucOpCode &BIT(5)) +GET_BIT(ucOpCode &BIT(4)) +GET_BIT(ucOpCode &BIT(3)) +GET_BIT(ucOpCode &BIT(2)) +GET_BIT(ucOpCode &BIT(1)) +GET_BIT(ucOpCode &BIT(0));
1028 ucAValue = ucAValue +GET_BIT(usCRCValus &BIT(0)) +GET_BIT(usCRCValus &BIT(1)) +GET_BIT(usCRCValus &BIT(2)) +GET_BIT(usCRCValus &BIT(3)) +GET_BIT(usCRCValus &BIT(4)) +GET_BIT(usCRCValus &BIT(5)) +GET_BIT(usCRCValus &BIT(6)) +GET_BIT(usCRCValus &BIT(7));
1029 ucBValue = GET_BIT(ucOpCode &BIT(6)) +GET_BIT(ucOpCode &BIT(5)) +GET_BIT(ucOpCode &BIT(4)) +GET_BIT(ucOpCode &BIT(3)) +GET_BIT(ucOpCode &BIT(2)) +GET_BIT(ucOpCode &BIT(1)) +GET_BIT(ucOpCode &BIT(0));
1030 ucBValue = ucBValue +GET_BIT(usCRCValus &BIT(0)) +GET_BIT(usCRCValus &BIT(1)) +GET_BIT(usCRCValus &BIT(2)) +GET_BIT(usCRCValus &BIT(3)) +GET_BIT(usCRCValus &BIT(4)) +GET_BIT(usCRCValus &BIT(5)) +GET_BIT(usCRCValus &BIT(6));
1031 ucPValue = ucAValue +GET_BIT(usCRCValus &BIT(8));
1032
1033 if(ucAValue &BIT(0))
1034 {
1035 usCommand |= BIT(15);
1036 }
1037
1038 if(ucBValue &BIT(0))
1039 {
1040 usCommand |= BIT(14);
1041 }
1042
1043 if(ucCValue &BIT(0))
1044 {
1045 usCommand |= BIT(13);
1046 }
1047
1048 if(ucDValue &BIT(0))
1049 {
1050 usCommand |= BIT(12);
1051 }
1052
1053 if(ucEValue &BIT(0))
1054 {
1055 usCommand |= BIT(11);
1056 }
1057
1058 if(ucFValue &BIT(0))
1059 {
1060 usCommand |= BIT(10);
1061 }
1062
1063 if(ucGValue &BIT(0))
1064 {
1065 usCommand |= BIT(9);
1066 }
1067
1068 if(ucHValue &BIT(0))
1069 {
1070 usCommand |= BIT(8);
1071 }
1072
1073 if(ucIValue &BIT(0))
1074 {
1075 usCommand |= BIT(7);
1076 }
1077
1078 if(ucJValue &BIT(0))
1079 {
1080 usCommand |= BIT(6);
1081 }
1082
1083 if(ucKValue &BIT(0))
1084 {
1085 usCommand |= BIT(5);
1086 }
1087
1088 if(ucLValue &BIT(0))
1089 {
1090 usCommand |= BIT(4);
1091 }
1092
1093 if(ucMValue &BIT(0))
1094 {
1095 usCommand |= BIT(3);
1096 }
1097
1098 if(ucNValue &BIT(0))
1099 {
1100 usCommand |= BIT(2);
1101 }
1102
1103 if(ucOValue &BIT(0))
1104 {
1105 usCommand |= BIT(1);
1106 }
1107
1108 if(ucPValue &BIT(0))
1109 {
1110 usCommand |= BIT(0);
1111 }
1112
1113 return usCommand;
1114 }
1115
1116 //**************************************************************************
1117 // [Function Name]:
1118 // _mhal_mhl_ECbusInitialSetting()
1119 // [Description]
1120 //
1121 // [Arguments]:
1122 //
1123 // [Return]:
1124 //
1125 //**************************************************************************
_mhal_mhl_ECbusInitialSetting(void)1126 void _mhal_mhl_ECbusInitialSetting(void)
1127 {
1128 W2BYTEMSK(REG_MHL_ECBUS_PHY_69, 0x35, BMASK(6:4)| BMASK(2:0)); // [6:4]: rasing pattern type, [2:0]: deglitch after reorder
1129
1130 W2BYTEMSK(REG_MHL_ECBUS_PHY_4C, 0x7780, BMASK(15:4));
1131 W2BYTEMSK(REG_MHL_ECBUS_PHY_4D, 0x8B14, BMASK(15:1));
1132 W2BYTEMSK(REG_MHL_ECBUS_PHY_4E, 0x001C, BMASK(15:0));
1133 W2BYTEMSK(REG_MHL_ECBUS_PHY_51, 0x0100, BMASK(15:0));
1134 W2BYTEMSK(REG_MHL_ECBUS_PHY_56, 0x0200, BMASK(15:0));
1135 W2BYTEMSK(REG_MHL_ECBUS_PHY_4A, BMASK(14:13), BMASK(14:13)); // [14:13]
1136 W2BYTEMSK(REG_MHL_ECBUS_PHY_4B, BMASK(14:13), BMASK(14:13));
1137 W2BYTEMSK(REG_MHL_ECBUS_PHY_55, 0, BMASK(15:4)); //[7:0]
1138 W2BYTEMSK(REG_MHL_ECBUS_PHY_4F, 0x0F00, BMASK(15:0)); // [7:4]:reg_ecbss_afe_tx_dri_step
1139 W2BYTEMSK(REG_MHL_ECBUS_PHY_78, BIT(0), BIT(0));
1140
1141 W2BYTEMSK(REG_MHL_ECBUS_0E, 8, BMASK(4:0));
1142 W2BYTEMSK(REG_MHL_ECBUS_2D, BIT(3), BIT(3));
1143
1144 //auto reset turn on
1145 W2BYTEMSK(REG_MHL_ECBUS_PHY_7F, BIT(2), BIT(2)); // [2]:reg_rst_aft_clklck_en
1146 W2BYTEMSK(REG_MHL_ECBUS_00, BMASK(4:3), BMASK(4:3)); // [4]:reg_rst_aft_fail_en, [3]:reg_rst_aft_clklck_en
1147
1148 // ECbus initial
1149 W2BYTEMSK(REG_MHL_ECBUS_02, BIT(7), BMASK(13:8)| BIT(7)); // [7]
1150 W2BYTEMSK(REG_MHL_ECBUS_PHY_6D, BIT(5), BMASK(6:5));
1151 W2BYTEMSK(REG_MHL_ECBUS_PHY_57, 0x06, BMASK(3:0)); // [11:8]:
1152 W2BYTEMSK(REG_MHL_ECBUS_PHY_68, 0x30, BMASK(6:4)); // [6:4]: pre-deglitch
1153 W2BYTEMSK(REG_MHL_ECBUS_PHY_69, 0x50, BMASK(6:4)| BMASK(2:0)); // [6:4]: rasing pattern type, [2:0]: deglitch after reorder
1154 W2BYTEMSK(REG_MHL_ECBUS_PHY_65, 0x08, BMASK(5:0)); // [5:0]: reg_dat_lsb_mask; after analog rwa data deglicth,re-order,the lsb data 1 will be mask
1155
1156 //U02 ECO item setting
1157 W2BYTEMSK(REG_MHL_ECBUS_77, (_mhal_mhl_GetEMSCOneByteCRC(5) << 8)| _mhal_mhl_GetEMSCOneByteCRC(4), BMASK(15:0)); // [15:8]:EMSC neck, [7:0]:EMSC ack
1158 W2BYTEMSK(REG_MHL_ECBUS_78, (_mhal_mhl_GetEMSCOneByteCRC(7) << 8)| _mhal_mhl_GetEMSCOneByteCRC(6), BMASK(15:0)); // [15:8]:Dstart, [7:0]:grant
1159 W2BYTEMSK(REG_MHL_ECBUS_79, BIT(11)| (_mhal_mhl_GetEMSCTwoByteCRC(1, 1) << 3)| (_mhal_mhl_GetEMSCTwoByteCRC(1, 2) << 6), BIT(11)| BMASK(8:6)| BMASK(5:3)); // [8:6]:EMSC errsum cmd CRC, [5:3]:EMSC errCRC cmd CRC
1160 W2BYTEMSK(REG_MHL_ECBUS_PHY_13, BIT(4), BIT(4)); //
1161 W2BYTEMSK(REG_MHL_ECBUS_PHY_51, BIT(11), BIT(11)); //
1162
1163 //eCBUS fsm timing
1164 W2BYTEMSK(REG_MHL_ECBUS_04, 0xE0E, BMASK(14:8)| BMASK(6:0)); // [14:8]: reg_t_sink_cal, [6:0]: reg_t_snk_cal 1; sink sends eCBUS clock after detecting eCBUS clock form source.
1165 W2BYTEMSK(REG_MHL_ECBUS_06, 0x1C00, BMASK(14:8)); // [14:8]: reg_t_snk_tdm;
1166 W2BYTEMSK(REG_MHL_ECBUS_03, BMASK(15:14), BMASK(15:14)); // [15]:reg_wait_tdm_timer_dis [14]:reg_wait_comma2_timer_dis
1167 W2BYTEMSK(REG_MHL_ECBUS_07, 0x104, BMASK(14:8)| BMASK(6:0)); // [14:8]: reg_t_snk_tdm;
1168 W2BYTEMSK(REG_MHL_ECBUS_3F, 0, BMASK(1:0)); //
1169 W2BYTEMSK(REG_MHL_ECBUS_48, 0, BMASK(2:0)); //
1170
1171 //clock detect setting
1172 W2BYTEMSK(REG_MHL_ECBUS_PHY_70, 0x032B, BMASK(15:0)); // [15:0]:reg_crlock_mid; the CR lock reference value
1173 W2BYTEMSK(REG_MHL_ECBUS_PHY_71, 0x0C04, BMASK(15:0)); // [15:8]:reg_crlock_thr, the CR lock reference failure threshold range; [7:0]:reg_crlock_thr, the CR lock reference correct threshold range;
1174 W2BYTEMSK(REG_MHL_ECBUS_PHY_72, 0x0007, BMASK(15:0)); // [12:8]:reg_cr_unlock_num, clock unlock threshold; [4:0]:reg_cr_lock_num; CR lock success threshold time.
1175
1176 #if(MHL_ECBUS_AUTO_TRAINING)
1177 //auto training testing
1178 W2BYTEMSK(REG_MHL_ECBUS_PHY_5C, 0x010A, BMASK(15:0)); // [10:8]:reg_txloc_golden_lowr_tol, [5:0]:reg_txloc_golden_lower,
1179 W2BYTEMSK(REG_MHL_ECBUS_PHY_66, 0x2117, BMASK(15:0)); // [14:12]:reg_txloc_golden2_tol, [10:8]:reg_txloc_rev_golden_tol, [5:0]:reg_txloc_rev_golden
1180 W2BYTEMSK(REG_MHL_ECBUS_PHY_67, 0x0403, BMASK(15:0)); // [14:12]:reg_val_aft_adj_ok, [10:8]:reg_txloc_txdelay_add, [6:4]:reg_flow_retry_r, [2:0]:reg_flow_retry
1181 W2BYTEMSK(REG_MHL_ECBUS_PHY_69, BIT(10), BMASK(11:10)); // [11:10]:reg_txloc_set_time
1182 W2BYTEMSK(REG_MHL_ECBUS_PHY_6A, 0xf117, BMASK(15:0)); // [15:12]:reg_txloc_lck_thr, [10:8]:reg_txloc_golden_tol, [5:0]:ret_txloc_golden
1183 #else
1184 // Skip atop training
1185 // REG_PM_MHL_CBUS2_4A [14]tx_rep_pd_ove = 1 [13]tx_rep_pd_ov [8]:tx_width_ove = 1 [7:4]:tx_width_ov
1186 W2BYTEMSK(REG_MHL_ECBUS_PHY_4A, BIT(8)| 0x22, BIT(8)| BMASK(7:4));
1187
1188 // REG_PM_MHL_CBUS2_4B ,[14]tx_pd_ove = 1 [13]tx_pd_ov [8]:tx_delay_ove = 1 [7:4]:tx_delay_ov
1189 W2BYTEMSK(REG_MHL_ECBUS_PHY_4B, BIT(8)| 0x00, BIT(8)| BMASK(7:4));
1190
1191 //W2BYTEMSK(REG_MHL_ECBUS_PHY_6C, 0x8000, BMASK(15:8));
1192 W2BYTEMSK(REG_MHL_ECBUS_PHY_6D, BIT(8), BIT(8));
1193
1194 W2BYTEMSK(REG_MHL_ECBUS_PHY_6C, 0x0000, BMASK(15:0));
1195 //W2BYTEMSK(REG_MHL_ECBUS_04, (30 << 8), BMASK(14:8));
1196 #endif
1197 }
1198
1199 //**************************************************************************
1200 // [Function Name]:
1201 // _mhal_mhl_SetECbusStateChangeInterrupt()
1202 // [Description]
1203 //
1204 // [Arguments]:
1205 //
1206 // [Return]:
1207 //
1208 //**************************************************************************
_mhal_mhl_SetECbusStateChangeInterrupt(MS_BOOL bEnableFlag)1209 void _mhal_mhl_SetECbusStateChangeInterrupt(MS_BOOL bEnableFlag)
1210 {
1211 if(bEnableFlag)
1212 {
1213 W2BYTEMSK(REG_MHL_ECBUS_36, 0, BIT(0)); // Ecbus state change int mask
1214 }
1215 else
1216 {
1217 W2BYTEMSK(REG_MHL_ECBUS_36, BIT(0), BIT(0)); // Ecbus state change int mask
1218 }
1219
1220 W2BYTEMSK(REG_MHL_ECBUS_34, BIT(0), BIT(0)); // Ecbus state change int clear
1221 }
1222
1223 //**************************************************************************
1224 // [Function Name]:
1225 // _mhal_mhl_SetEMSCReceiveInterrupt()
1226 // [Description]
1227 //
1228 // [Arguments]:
1229 //
1230 // [Return]:
1231 //
1232 //**************************************************************************
_mhal_mhl_SetEMSCReceiveInterrupt(MS_BOOL bEnableFlag)1233 void _mhal_mhl_SetEMSCReceiveInterrupt(MS_BOOL bEnableFlag)
1234 {
1235 W2BYTEMSK(REG_MHL_ECBUS_36, bEnableFlag? 0: BIT(12), BIT(12)); // eMSC receive int mask
1236 W2BYTEMSK(REG_MHL_ECBUS_34, BIT(12), BIT(12)); // eMSC receive int clear
1237 }
1238
1239 //**************************************************************************
1240 // [Function Name]:
1241 // _mhal_mhl_CbusConnectCheckEnable()
1242 // [Description]
1243 //
1244 // [Arguments]:
1245 //
1246 // [Return]:
1247 //
1248 //**************************************************************************
_mhal_mhl_CbusConnectCheckEnable(MS_BOOL bEnableFlag)1249 void _mhal_mhl_CbusConnectCheckEnable(MS_BOOL bEnableFlag)
1250 {
1251 W2BYTEMSK(REG_PM_MHL_CBUS_0B, bEnableFlag? MHL_CBUS_CONNECT_CHECK_VALUE: 0, BMASK(15:0)); // [15:0]: Disable connection check
1252 }
1253
1254 //**************************************************************************
1255 // [Function Name]:
1256 // _mhal_mhl_ECbusEnableSetting()
1257 // [Description]
1258 //
1259 // [Arguments]:
1260 //
1261 // [Return]:
1262 //
1263 //**************************************************************************
_mhal_mhl_ECbusEnableSetting(MS_BOOL bEnableFlag)1264 void _mhal_mhl_ECbusEnableSetting(MS_BOOL bEnableFlag)
1265 {
1266 W2BYTEMSK(REG_MHL_ECBUS_PHY_4D, bEnableFlag? 0: BIT(0), BIT(0)); // ECbus PLL pd
1267 //W2BYTEMSK(REG_MHL_ECBUS_PHY_55, bEnableFlag? 0: BIT(14), BIT(14)); // Rx power down
1268 W2BYTEMSK(REG_MHL_ECBUS_PHY_57, bEnableFlag? BIT(3): BIT(2), BMASK(3:2)); //
1269 W2BYTEMSK(REG_MHL_ECBUS_PHY_6F, bEnableFlag? BIT(8): 0, BIT(8)); // ECbus clock detect
1270 W2BYTEMSK(REG_MHL_ECBUS_PHY_4A, bEnableFlag? 0: BIT(13), BIT(13));
1271 W2BYTEMSK(REG_MHL_ECBUS_PHY_4B, bEnableFlag? 0: BIT(13), BIT(13));
1272
1273 if(bEnableFlag)
1274 {
1275 W2BYTEMSK(REG_PM_MHL_CBUS_00, BIT(13), BIT(13)); // [13]: ECbus on
1276 }
1277 else
1278 {
1279 W2BYTEMSK(REG_PM_MHL_CBUS_00, BIT(14), BIT(14)); // [14]: ECbus off
1280 }
1281 }
1282
1283 //**************************************************************************
1284 // [Function Name]:
1285 // _mhal_mhl_ECbusDmuxEnable()
1286 // [Description]
1287 //
1288 // [Arguments]:
1289 //
1290 // [Return]:
1291 //
1292 //**************************************************************************
_mhal_mhl_ECbusDmuxEnable(MS_BOOL bEnableFlag)1293 void _mhal_mhl_ECbusDmuxEnable(MS_BOOL bEnableFlag)
1294 {
1295 W2BYTEMSK(REG_MHL_ECBUS_PHY_4F, bEnableFlag? BIT(3): 0, BIT(3)); // [3]: Enable ECbus dmux
1296 }
1297
1298 //**************************************************************************
1299 // [Function Name]:
1300 // _mhal_mhl_CbusEngineReset()
1301 // [Description]
1302 //
1303 // [Arguments]:
1304 //
1305 // [Return]:
1306 //
1307 //**************************************************************************
_mhal_mhl_CbusEngineReset(void)1308 void _mhal_mhl_CbusEngineReset(void)
1309 {
1310 W2BYTEMSK(REG_PM_MHL_CBUS_00, BIT(0), BIT(0));
1311 W2BYTEMSK(REG_PM_MHL_CBUS_00, 0, BIT(0));
1312 }
1313
1314 //**************************************************************************
1315 // [Function Name]:
1316 // _mhal_mhl_ECbusStateReset()
1317 // [Description]
1318 //
1319 // [Arguments]:
1320 //
1321 // [Return]:
1322 //
1323 //**************************************************************************
_mhal_mhl_ECbusStateReset(void)1324 void _mhal_mhl_ECbusStateReset(void)
1325 {
1326 W2BYTEMSK(REG_MHL_ECBUS_00, BMASK(1:0), BMASK(1:0)); // ECbus state reset
1327 W2BYTEMSK(REG_MHL_ECBUS_00, 0, BMASK(1:0)); // ECbus state reset
1328 }
1329
1330 //**************************************************************************
1331 // [Function Name]:
1332 // _mhal_mhl_SetShortReadAddress()
1333 // [Description]
1334 //
1335 // [Arguments]:
1336 //
1337 // [Return]:
1338 //
1339 //**************************************************************************
_mhal_mhl_SetShortReadAddress(MS_BOOL bECbusEnable)1340 void _mhal_mhl_SetShortReadAddress(MS_BOOL bECbusEnable)
1341 {
1342 W2BYTEMSK(REG_MHL_CBUS_17, bECbusEnable? 0x7000: 0x0800, BMASK(15:8)); // [15:8]: reg_ddc_hdcp_short_read_address
1343
1344 bECbusEnableFlag = bECbusEnable;
1345 }
1346
1347 //**************************************************************************
1348 // [Function Name]:
1349 // _mhal_mhl_Version3PhyEnable()
1350 // [Description]
1351 //
1352 // [Arguments]:
1353 //
1354 // [Return]:
1355 //
1356 //**************************************************************************
_mhal_mhl_Version3PhyEnable(MS_U8 ucCbusSelect,MS_BOOL bEnableFlag)1357 void _mhal_mhl_Version3PhyEnable(MS_U8 ucCbusSelect, MS_BOOL bEnableFlag)
1358 {
1359 switch(ucCbusSelect)
1360 {
1361 #if(MHL_FUNCTION_SUPPORT_PORTA)
1362 case MHL_CBUS_SELECT_PORTA:
1363 if(GET_MHL_PATH_SUPPORT_PORTA())
1364 {
1365
1366 }
1367
1368 break;
1369 #endif
1370
1371 #if(MHL_FUNCTION_SUPPORT_PORTB)
1372 case MHL_CBUS_SELECT_PORTB:
1373 if(GET_MHL_PATH_SUPPORT_PORTB())
1374 {
1375 W2BYTEMSK(REG_DVI_DTOP_DUAL_P0_60_L, bEnableFlag? BMASK(10:8): 0, BMASK(10:8)); // [8]: MHL3 engine enable
1376 W2BYTEMSK(REG_COMBO_PHY0_P0_73_L, bEnableFlag? MHL_EQ_30_SETTING_VALUE: MHL_EQ_20_SETTING_VALUE, BMASK(4:0)); // B channel EQ
1377 }
1378
1379 break;
1380 #endif
1381
1382 #if(MHL_FUNCTION_SUPPORT_PORTC)
1383 case MHL_CBUS_SELECT_PORTC:
1384 if(GET_MHL_PATH_SUPPORT_PORTC())
1385 {
1386 W2BYTEMSK(REG_DVI_DTOP_DUAL_P0_60_L, bEnableFlag? BMASK(10:8): 0, BMASK(10:8)); // [8]: MHL3 engine enable
1387 W2BYTEMSK(REG_COMBO_PHY0_P0_73_L, bEnableFlag? MHL_EQ_30_SETTING_VALUE: MHL_EQ_20_SETTING_VALUE, BMASK(4:0)); // B channel EQ
1388 }
1389
1390 break;
1391 #endif
1392
1393 #if(MHL_FUNCTION_SUPPORT_PORTD)
1394 case MHL_CBUS_SELECT_PORTD:
1395 if(GET_MHL_PATH_SUPPORT_PORTD())
1396 {
1397
1398 }
1399
1400 break;
1401 #endif
1402
1403 default:
1404
1405 break;
1406 };
1407 }
1408
1409 //**************************************************************************
1410 // [Function Name]:
1411 // _mhal_mhl_ECbusStateChangeProc()
1412 // [Description]
1413 //
1414 // [Arguments]:
1415 //
1416 // [Return]:
1417 //
1418 //**************************************************************************
_mhal_mhl_ECbusStateChangeProc(void)1419 void _mhal_mhl_ECbusStateChangeProc(void)
1420 {
1421 MS_U8 ucECbusState = (R2BYTE(REG_MHL_ECBUS_03) &0xF0) >> 4; // [7:4]: ECbus state
1422
1423 if(ucECbusState != ucECbusTrainState)
1424 {
1425 if(ucECbusState == MHL_ECBUS_STATE_WAIT_CLOCK_LOCK)
1426 {
1427 //W2BYTEMSK(REG_MHL_ECBUS_PHY_4D, 0, BIT(0)); // [0]: ECbus PLL pd
1428 }
1429 else if(ucECbusState == MHL_ECBUS_STATE_WAIT_SEND_CLOCK)
1430 {
1431 if(R2BYTE(REG_MHL_ECBUS_PHY_4D) & BIT(15))
1432 {
1433 //_mhal_mhl_ECbusDmuxEnable(TRUE);
1434 }
1435
1436 W2BYTEMSK(REG_MHL_ECBUS_34, BIT(4), BIT(4)); // [4]
1437 }
1438 else if(ucECbusState == MHL_ECBUS_STATE_SOURCE_ACTIVE)
1439 {
1440
1441 }
1442 else if(ucECbusState == MHL_ECBUS_STATE_ACTIVE)
1443 {
1444
1445 }
1446 else if(ucECbusState == MHL_ECBUS_STATE_FAIL)
1447 {
1448 //_mhal_mhl_ECbusDmuxEnable(FALSE);
1449
1450 //W2BYTEMSK(REG_MHL_ECBUS_PHY_56, 0x0207, BMASK(15:0)); //
1451 #if(MHL_ECBUS_AUTO_TRAINING)
1452 W2BYTEMSK(REG_MHL_ECBUS_PHY_4A, BIT(13), BIT(13));//
1453 #endif
1454 //W2BYTEMSK(REG_MHL_ECBUS_PHY_4D, BIT(0), BIT(0)); // [0]: ECbus PLL pd
1455 #if(MHL_ECBUS_AUTO_TRAINING)
1456 W2BYTEMSK(REG_MHL_ECBUS_PHY_4B, BIT(13)| BIT(12), BMASK(14:12)); // delay
1457 #endif
1458
1459 _mhal_mhl_ECbusStateReset();
1460
1461 ucECbusTrainFailCount++;
1462 }
1463
1464 ucECbusTrainState = ucECbusState;
1465 }
1466 }
1467
1468 //**************************************************************************
1469 // [Function Name]:
1470 // _mhal_mhl_ECbusModeUpProc()
1471 // [Description]
1472 //
1473 // [Arguments]:
1474 //
1475 // [Return]:
1476 //
1477 //**************************************************************************
_mhal_mhl_ECbusModeUpProc(void)1478 void _mhal_mhl_ECbusModeUpProc(void)
1479 {
1480 W2BYTEMSK(REG_MHL_ECBUS_34, BIT(4), BIT(4)); // [4]: clear PLL lock status
1481 W2BYTEMSK(REG_MHL_ECBUS_34, 0, BIT(4)); // [4]: clear PLL lock status
1482
1483 //W2BYTEMSK(REG_MHL_ECBUS_PHY_56, 0x0207, BMASK(15:0));
1484 #if(MHL_ECBUS_AUTO_TRAINING)
1485 W2BYTEMSK(REG_MHL_ECBUS_PHY_4A, BIT(13), BIT(13));
1486 W2BYTEMSK(REG_MHL_ECBUS_PHY_4B, BMASK(14:12), BMASK(14:12)); // delay
1487 #endif
1488 }
1489
1490 //**************************************************************************
1491 // [Function Name]:
1492 // _mhal_mhl_ECbusModeDownProc()
1493 // [Description]
1494 //
1495 // [Arguments]:
1496 //
1497 // [Return]:
1498 //
1499 //**************************************************************************
_mhal_mhl_ECbusModeDownProc(void)1500 void _mhal_mhl_ECbusModeDownProc(void)
1501 {
1502 //W2BYTEMSK(REG_MHL_ECBUS_PHY_56, 0x0207, BMASK(15:0));
1503 W2BYTEMSK(REG_MHL_ECBUS_PHY_4A, BIT(13), BIT(13));
1504 }
1505
1506 //**************************************************************************
1507 // [Function Name]:
1508 // _mhal_mhl_MHL3MuxSetting0()
1509 // [Description]
1510 //
1511 // [Arguments]:
1512 //
1513 // [Return]:
1514 //
1515 //**************************************************************************
_mhal_mhl_MHL3MuxSetting0(MS_BOOL bLinkRate6GFlag)1516 void _mhal_mhl_MHL3MuxSetting0(MS_BOOL bLinkRate6GFlag)
1517 {
1518 W2BYTEMSK(REG_HDMI2_DUAL_0_54_L, bLinkRate6GFlag? 0: BIT(1), BMASK(1:0)); // [1:0]: reg_avg_ctrl_case
1519 }
1520
1521 //**************************************************************************
1522 // [Function Name]:
1523 // _mhal_mhl_GetSRAMReceiveEMSCData()
1524 // [Description]
1525 //
1526 // [Arguments]:
1527 //
1528 // [Return]:
1529 //
1530 //**************************************************************************
_mhal_mhl_GetSRAMReceiveEMSCData(void)1531 MS_U8 _mhal_mhl_GetSRAMReceiveEMSCData(void)
1532 {
1533 W2BYTEMSK(REG_MHL_ECBUS_23, BIT(15), BIT(15));
1534
1535 while((R2BYTE(REG_MHL_ECBUS_23) & BIT(14)) == BIT(14));
1536
1537 return (R2BYTE(REG_MHL_ECBUS_22) &BMASK(7:0));
1538 }
1539
1540 //**************************************************************************
1541 // [Function Name]:
1542 // _mhal_mhl_GetSRAMReceiveEMSCData()
1543 // [Description]
1544 //
1545 // [Arguments]:
1546 //
1547 // [Return]:
1548 //
1549 //**************************************************************************
_mhal_mhl_InsertSRAMSendEMSCData(MS_U8 ucSendEMSC)1550 void _mhal_mhl_InsertSRAMSendEMSCData(MS_U8 ucSendEMSC)
1551 {
1552 W2BYTEMSK(REG_MHL_ECBUS_20, ucSendEMSC, BMASK(7:0));
1553
1554 W2BYTEMSK(REG_MHL_ECBUS_21, BIT(15), BIT(15));
1555
1556 while((R2BYTE(REG_MHL_ECBUS_21) & BIT(14)) == BIT(14));
1557 }
1558
1559 #if(MHL_ECBUS_COMMAND_PARSING)
1560 //**************************************************************************
1561 // [Function Name]:
1562 // _mhal_mhl_ParsingECbusCommand()
1563 // [Description]
1564 //
1565 // [Arguments]:
1566 //
1567 // [Return]:
1568 //
1569 //**************************************************************************
_mhal_mhl_ParsingECbusCommand(MS_U16 * usECbusData)1570 void _mhal_mhl_ParsingECbusCommand(MS_U16 *usECbusData)
1571 {
1572 MS_U8 ucTimes = 0;
1573 MS_U16 ustemp = 0;
1574 MS_U16 usCounnter = 0;
1575 MS_U16 usValue = 0;
1576
1577 for(ustemp = 0; ustemp < MHL_BUFFER_ECBUS_DATA_LENGTH; ustemp++)
1578 {
1579 if((usECbusData[ustemp] &BMASK(7:0)) == 0x39) // Find CBUS1_START
1580 {
1581 ucTimes = 0;
1582
1583 if(usECbusData[ustemp] &BIT(15)) // Send case
1584 {
1585 for(usCounnter = ustemp +1; usCounnter < MHL_BUFFER_ECBUS_DATA_LENGTH; usCounnter++)
1586 {
1587 if(usECbusData[usCounnter] &BIT(15))
1588 {
1589 usValue = usValue << 8;
1590 usValue = usValue |(usECbusData[usCounnter] &BMASK(7:0));
1591
1592 ucTimes++;
1593 }
1594
1595 if(ucTimes == 2)
1596 {
1597 usValue = usValue >> 5;
1598 ucTimes = usValue >> 8;
1599
1600 if(ucTimes == 5)
1601 {
1602 MHAL_MHL_MSG_DEBUG(" MHL [SK][MSC][C] = %x\r\n", (usValue &BMASK(7:0)));
1603 }
1604 else if(ucTimes == 4)
1605 {
1606 MHAL_MHL_MSG_DEBUG(" MHL [SK][MSC][D] = %x\r\n", (usValue &BMASK(7:0)));
1607 }
1608 else if(ucTimes == 1)
1609 {
1610 MHAL_MHL_MSG_DEBUG(" MHL [SK][DDC][C] = %x\r\n", (usValue &BMASK(7:0)));
1611 }
1612 else if(ucTimes == 0)
1613 {
1614 MHAL_MHL_MSG_DEBUG(" MHL [SK][DDC][D] = %x\r\n", (usValue &BMASK(7:0)));
1615 }
1616 else
1617 {
1618 MHAL_MHL_MSG_DEBUG(" MHL [SK] unknow = %x\r\n", (usValue &BMASK(7:0)));
1619 }
1620
1621 break;
1622 }
1623 }
1624 }
1625 else // Receive case
1626 {
1627 for(usCounnter = ustemp +1; usCounnter < MHL_BUFFER_ECBUS_DATA_LENGTH; usCounnter++)
1628 {
1629 if((usECbusData[usCounnter] &BIT(15)) == 0)
1630 {
1631 usValue = usValue << 8;
1632 usValue = usValue |(usECbusData[usCounnter] &BMASK(7:0));
1633
1634 ucTimes++;
1635 }
1636
1637 if(ucTimes == 2)
1638 {
1639 usValue = usValue >> 5;
1640 ucTimes = usValue >> 8;
1641
1642 if(ucTimes == 5)
1643 {
1644 MHAL_MHL_MSG_DEBUG(" MHL [SO][MSC][C] = %x\r\n", (usValue &BMASK(7:0)));
1645 }
1646 else if(ucTimes == 4)
1647 {
1648 MHAL_MHL_MSG_DEBUG(" MHL [SO][MSC][D] = %x\r\n", (usValue &BMASK(7:0)));
1649 }
1650 else if(ucTimes == 1)
1651 {
1652 MHAL_MHL_MSG_DEBUG(" MHL [SO][DDC][C] = %x\r\n", (usValue &BMASK(7:0)));
1653 }
1654 else if(ucTimes == 0)
1655 {
1656 MHAL_MHL_MSG_DEBUG(" MHL [SO][DDC][D] = %x\r\n", (usValue &BMASK(7:0)));
1657 }
1658 else
1659 {
1660 MHAL_MHL_MSG_DEBUG(" MHL [SO] unknow = %x\r\n", (usValue &BMASK(7:0)));
1661 }
1662
1663 break;
1664 }
1665 }
1666 }
1667 }
1668 }
1669 }
1670
1671 //**************************************************************************
1672 // [Function Name]:
1673 // _mhal_mhl_GetECbusCommand()
1674 // [Description]
1675 //
1676 // [Arguments]:
1677 //
1678 // [Return]:
1679 //
1680 //**************************************************************************
_mhal_mhl_GetECbusCommand(void)1681 void _mhal_mhl_GetECbusCommand(void)
1682 {
1683 MS_BOOL bReDoFlag = TRUE;
1684 MS_U8 ucReceiveData = 0;
1685 MS_U8 ucPreReceiveData = 0;
1686 MS_U8 ucSendData = 0;
1687 MS_U8 ucPreSendData = 0;
1688 MS_U16 usECbusCData[MHL_BUFFER_ECBUS_DATA_LENGTH] = {0};
1689 MS_U16 ustemp = 0;
1690 MS_U16 usCounnter = 0;
1691 static MS_U32 ulTimeout = 0;
1692
1693 if(ulTimeout < 40000000)
1694 {
1695 do
1696 {
1697 ucReceiveData = (R2BYTE(REG_MHL_ECBUS_7C) &BMASK(7:0));
1698 ucSendData = (R2BYTE(REG_MHL_ECBUS_7C) >>8);
1699
1700 if((ucReceiveData != 0x5A) && (ucPreReceiveData != ucReceiveData))
1701 {
1702 usECbusCData[ustemp] = ucReceiveData;
1703 ustemp++;
1704
1705 //msg_mhl(printf(" MHL receive data = %x, %d\r\n", ucReceiveData, ustemp));
1706
1707 ucPreReceiveData = ucReceiveData;
1708 bReDoFlag = TRUE;
1709 usCounnter = 0;
1710 }
1711
1712 if((ucSendData != 0x5A)&& (ucPreSendData != ucSendData))
1713 {
1714 usECbusCData[ustemp] = ucSendData |BIT(15);
1715 ustemp++;
1716
1717 //msg_mhl(printf(" MHL send data = %x, %d\r\n", ucSendData, ustemp));
1718
1719 ucPreSendData = ucSendData;
1720 bReDoFlag = TRUE;
1721 usCounnter = 0;
1722 }
1723
1724 if(ustemp == MHL_BUFFER_ECBUS_DATA_LENGTH)
1725 {
1726 bReDoFlag = FALSE;
1727
1728 for(usCounnter = 0; usCounnter < MHL_BUFFER_ECBUS_DATA_LENGTH; usCounnter++)
1729 {
1730 MHAL_MHL_MSG_DEBUG(" MHL DDC data = %x\r\n", usECbusCData[usCounnter]);
1731 }
1732
1733 ustemp = 0;
1734
1735 _mhal_mhl_ParsingECbusCommand(usECbusCData);
1736 }
1737
1738 if(ulTimeout < 40000000)
1739 {
1740 ulTimeout++;
1741 }
1742 else
1743 {
1744 for(usCounnter = 0; usCounnter < ustemp; usCounnter++)
1745 {
1746 MHAL_MHL_MSG_DEBUG(" MHL DDC data = %x\r\n", usECbusCData[usCounnter]);
1747 }
1748
1749 bReDoFlag = FALSE;
1750 ustemp = 0;
1751
1752 _mhal_mhl_ParsingECbusCommand(usECbusCData);
1753 }
1754 }while(bReDoFlag);
1755 }
1756 }
1757
1758 #endif
1759
1760 //-------------------------------------------------------------------------------------------------
1761 // Global Functions
1762 //-------------------------------------------------------------------------------------------------
1763
1764 //**************************************************************************
1765 // [Function Name]:
1766 // mhal_mhl_GetCbusSelect()
1767 // [Description]
1768 //
1769 // [Arguments]:
1770 //
1771 // [Return]:
1772 //
1773 //**************************************************************************
mhal_mhl_GetCbusSelect(MS_U8 ucPort)1774 MS_U8 mhal_mhl_GetCbusSelect(MS_U8 ucPort)
1775 {
1776 MS_U8 uctemp = MHL_CBUS_SELECT_MASK;
1777
1778 switch(ucPort)
1779 {
1780 case MHL_DVI_PORT_A:
1781 uctemp = MHL_CBUS_SELECT_PORTA;
1782 break;
1783
1784 case MHL_DVI_PORT_B:
1785 uctemp = MHL_CBUS_SELECT_PORTB;
1786 break;
1787
1788 case MHL_DVI_PORT_C:
1789 uctemp = MHL_CBUS_SELECT_PORTC;
1790 break;
1791
1792 default:
1793
1794 break;
1795 };
1796
1797 return uctemp;
1798 }
1799
1800 //**************************************************************************
1801 // [Function Name]:
1802 // mhal_mhl_GetInputPort()
1803 // [Description]
1804 // MHL get current input port
1805 // [Arguments]:
1806 //
1807 // [Return]:
1808 //
1809 //**************************************************************************
mhal_mhl_GetInputPort(void)1810 MS_U8 mhal_mhl_GetInputPort(void)
1811 {
1812 return (R2BYTE(REG_PM_SLEEP_4D_L) &BMASK(2:0));
1813 }
1814
1815 //**************************************************************************
1816 // [Function Name]:
1817 // mhal_mhl_CheckInputPort()
1818 // [Description]
1819 // MHL check current input port
1820 // [Arguments]:
1821 //
1822 // [Return]:
1823 //
1824 //**************************************************************************
mhal_mhl_CheckInputPort(MS_U8 ucCbusSelect)1825 MS_BOOL mhal_mhl_CheckInputPort(MS_U8 ucCbusSelect)
1826 {
1827 MS_BOOL bindex = FALSE;
1828
1829 if(mhal_mhl_GetCbusSelect(mhal_mhl_GetInputPort()) == ucCbusSelect)
1830 {
1831 bindex = TRUE;
1832 }
1833
1834 return bindex;
1835 }
1836
1837 //**************************************************************************
1838 // [Function Name]:
1839 // mhal_mhl_CheckPIPWindow()
1840 // [Description]
1841 //
1842 // [Arguments]:
1843 //
1844 // [Return]:
1845 //
1846 //**************************************************************************
mhal_mhl_CheckPIPWindow(void)1847 MS_BOOL mhal_mhl_CheckPIPWindow(void)
1848 {
1849 MS_BOOL bFlag = FALSE;
1850 MS_U8 ucScalerMux = R2BYTE(0x102E02) &BMASK(7:0);
1851
1852 if(((ucScalerMux &BMASK(7:4)) >> 4) == MHL_SCALER_MUX_SELECT_DVI) // Check scaler main window mux
1853 {
1854 bFlag = TRUE;
1855 }
1856 else if((ucScalerMux &BMASK(3:0)) == MHL_SCALER_MUX_SELECT_DVI) // Check scaler sub window mux
1857 {
1858 bFlag = TRUE;
1859 }
1860
1861 return bFlag;
1862 }
1863
1864 //**************************************************************************
1865 // [Function Name]:
1866 // mhal_mhl_MHLSupportPath()
1867 // [Description]
1868 // MHL support path
1869 // [Arguments]:
1870 //
1871 // [Return]:
1872 //
1873 //**************************************************************************
mhal_mhl_MHLSupportPath(MS_U8 ucSelect)1874 void mhal_mhl_MHLSupportPath(MS_U8 ucSelect)
1875 {
1876 ucMHLSupportPort = ucSelect;
1877 }
1878
1879 //**************************************************************************
1880 // [Function Name]:
1881 // mhal_mhl_CheckEfuseControlFlag()
1882 // [Description]
1883 //
1884 // [Arguments]:
1885 //
1886 // [Return]:
1887 //
1888 //**************************************************************************
mhal_mhl_CheckEfuseControlFlag(MS_BOOL bEfuseFlag)1889 MS_BOOL mhal_mhl_CheckEfuseControlFlag(MS_BOOL bEfuseFlag)
1890 {
1891 MS_BOOL bFlag = FALSE;
1892
1893 #if(MHL_EFUSE_FUNCTION_CONTROL)
1894 MS_U8 uctemp = 0;
1895
1896 if(!bEfuseFlag)
1897 {
1898 for(uctemp = 0; uctemp < MHL_CBUS_SELECT_MASK; uctemp++)
1899 {
1900 mhal_mhl_CbusIsolate(uctemp, TRUE);
1901 }
1902
1903 bFlag = TRUE;
1904 }
1905
1906 #endif
1907
1908 return bFlag;
1909 }
1910
1911 //**************************************************************************
1912 // [Function Name]:
1913 // mhal_mhl_InsertChipIDforCheck()
1914 // [Description]
1915 //
1916 // [Arguments]:
1917 //
1918 // [Return]:
1919 //
1920 //**************************************************************************
mhal_mhl_InsertChipIDforCheck(MS_U8 ucChipID)1921 void mhal_mhl_InsertChipIDforCheck(MS_U8 ucChipID)
1922 {
1923 ucChipIDValue = ucChipID;
1924
1925 MHAL_MHL_MSG_INFO("** MHL Cbus index value %x\r\n", ucChipID);
1926 }
1927
1928 //**************************************************************************
1929 // [Function Name]:
1930 // mhal_mhl_CbusSelectSetMux()
1931 // [Description]
1932 //
1933 // [Arguments]:
1934 //
1935 // [Return]:
1936 //
1937 //**************************************************************************
mhal_mhl_CbusSelectSetMux(MS_U8 ucCbusSelect)1938 void mhal_mhl_CbusSelectSetMux(MS_U8 ucCbusSelect)
1939 {
1940 switch(ucCbusSelect)
1941 {
1942 #if(MHL_FUNCTION_SUPPORT_PORTA)
1943 case MHL_CBUS_SELECT_PORTA:
1944 if(GET_MHL_PATH_SUPPORT_PORTA())
1945 {
1946
1947 }
1948
1949 break;
1950 #endif
1951
1952 #if(MHL_FUNCTION_SUPPORT_PORTB)
1953 case MHL_CBUS_SELECT_PORTB:
1954 if(GET_MHL_PATH_SUPPORT_PORTB())
1955 {
1956
1957 }
1958
1959 break;
1960 #endif
1961
1962 #if(MHL_FUNCTION_SUPPORT_PORTC)
1963 case MHL_CBUS_SELECT_PORTC:
1964 if(GET_MHL_PATH_SUPPORT_PORTC())
1965 {
1966
1967 }
1968
1969 break;
1970 #endif
1971
1972 #if(MHL_FUNCTION_SUPPORT_PORTD)
1973 case MHL_CBUS_SELECT_PORTD:
1974 if(GET_MHL_PATH_SUPPORT_PORTD())
1975 {
1976
1977 }
1978
1979 break;
1980 #endif
1981
1982 default:
1983
1984 break;
1985 };
1986 }
1987
1988 //**************************************************************************
1989 // [Function Name]:
1990 // mhal_mhl_CableDetect()
1991 // [Description]
1992 // MHL cable detection
1993 // [Arguments]:
1994 //
1995 // [Return]:
1996 // TRUE: MHL cable plugged
1997 // FALSE: MHL cable unplugged
1998 //**************************************************************************
mhal_mhl_CableDetect(MS_U8 ucCbusSelect)1999 MS_BOOL mhal_mhl_CableDetect(MS_U8 ucCbusSelect)
2000 {
2001 MS_BOOL bFlag = FALSE;
2002
2003 switch(ucCbusSelect)
2004 {
2005 #if(MHL_FUNCTION_SUPPORT_PORTA)
2006 case MHL_CBUS_SELECT_PORTA:
2007 if(GET_MHL_PATH_SUPPORT_PORTA())
2008 {
2009
2010 }
2011
2012 break;
2013 #endif
2014
2015 #if(MHL_FUNCTION_SUPPORT_PORTB)
2016 case MHL_CBUS_SELECT_PORTB:
2017 if(GET_MHL_PATH_SUPPORT_PORTB())
2018 {
2019 bFlag = ((R2BYTE(REG_PM_MHL_CBUS_00) & BIT(10)) ? TRUE : FALSE);
2020 }
2021
2022 break;
2023 #endif
2024
2025 #if(MHL_FUNCTION_SUPPORT_PORTC)
2026 case MHL_CBUS_SELECT_PORTC:
2027 if(GET_MHL_PATH_SUPPORT_PORTC())
2028 {
2029 bFlag = ((R2BYTE(REG_PM_MHL_CBUS_00) & BIT(10)) ? TRUE : FALSE);
2030 }
2031
2032 break;
2033 #endif
2034
2035 #if(MHL_FUNCTION_SUPPORT_PORTD)
2036 case MHL_CBUS_SELECT_PORTD:
2037 if(GET_MHL_PATH_SUPPORT_PORTD())
2038 {
2039
2040 }
2041
2042 break;
2043 #endif
2044
2045 default:
2046
2047 break;
2048 };
2049
2050 return bFlag;
2051 }
2052
2053 //**************************************************************************
2054 // [Function Name]:
2055 // mhal_mhl_Accumulator_Clr()
2056 // [Description]
2057 // to clear accumulator when input is not MHL
2058 // [Arguments]:
2059 //
2060 // [Return]:
2061 //**************************************************************************
mhal_mhl_Accumulator_Clr(MS_U8 ucCbusSelect)2062 void mhal_mhl_Accumulator_Clr(MS_U8 ucCbusSelect)
2063 {
2064 switch(ucCbusSelect)
2065 {
2066 #if(MHL_FUNCTION_SUPPORT_PORTA)
2067 case MHL_CBUS_SELECT_PORTA:
2068 if(GET_MHL_PATH_SUPPORT_PORTA())
2069 {
2070
2071 }
2072
2073 break;
2074 #endif
2075
2076 #if(MHL_FUNCTION_SUPPORT_PORTB)
2077 case MHL_CBUS_SELECT_PORTB:
2078 if(GET_MHL_PATH_SUPPORT_PORTB())
2079 {
2080
2081 }
2082
2083 break;
2084 #endif
2085
2086 #if(MHL_FUNCTION_SUPPORT_PORTC)
2087 case MHL_CBUS_SELECT_PORTC:
2088 if(GET_MHL_PATH_SUPPORT_PORTC())
2089 {
2090
2091 }
2092
2093 break;
2094 #endif
2095
2096 #if(MHL_FUNCTION_SUPPORT_PORTD)
2097 case MHL_CBUS_SELECT_PORTD:
2098 if(GET_MHL_PATH_SUPPORT_PORTD())
2099 {
2100
2101 }
2102
2103 break;
2104 #endif
2105
2106 default:
2107
2108 break;
2109 };
2110 }
2111
2112 //**************************************************************************
2113 // [Function Name]:
2114 // mhal_mhl_CDRModeMonitor()
2115 // [Description]:
2116 // MHL CDR mode monitor
2117 // [Arguments]:
2118 // isCbusConnected: Cbus is at connected state or not
2119 // [Return]:
2120 //
2121 //**************************************************************************
mhal_mhl_CDRModeMonitor(MS_U8 ucCbusSelect,MS_BOOL bPathEnable)2122 MS_BOOL mhal_mhl_CDRModeMonitor(MS_U8 ucCbusSelect, MS_BOOL bPathEnable)
2123 {
2124 MS_BOOL bindex = FALSE;
2125 static MS_U8 ucStableCount = 0;
2126 static MS_BOOL bPLLPower[MHL_CBUS_SELECT_MASK] = {TRUE, TRUE, TRUE};
2127
2128 switch(ucCbusSelect)
2129 {
2130 #if(MHL_FUNCTION_SUPPORT_PORTA)
2131 case MHL_CBUS_SELECT_PORTA:
2132 if(GET_MHL_PATH_SUPPORT_PORTA())
2133 {
2134
2135 }
2136
2137 break;
2138 #endif
2139
2140 #if(MHL_FUNCTION_SUPPORT_PORTB)
2141 case MHL_CBUS_SELECT_PORTB:
2142 if(GET_MHL_PATH_SUPPORT_PORTB())
2143 {
2144 if(mhal_mhl_CheckInputPort(ucCbusSelect))
2145 {
2146 if(bPathEnable && (_mhal_mhl_CheckClockStatus(ucCbusSelect)))
2147 {
2148 if(ucStableCount < (MHL_CDR_FORCE_THRESHOLD +1))
2149 {
2150 ucStableCount++;
2151 }
2152
2153 if(!bPLLPower[ucCbusSelect])
2154 {
2155 bPLLPower[ucCbusSelect] = TRUE;
2156 }
2157
2158 if((R2BYTE(REG_DVI_DTOP_DUAL_P0_31_L) &BIT(6)) == BIT(6)) // DE stable
2159 {
2160 if(ucStableCount < MHL_CDR_STABLE_THRESHOLD)
2161 {
2162 ucStableCount = MHL_CDR_STABLE_THRESHOLD;
2163 }
2164 else if(ucStableCount == (MHL_CDR_FORCE_THRESHOLD -1))
2165 {
2166 W2BYTEMSK(REG_DVI_DTOP_DUAL_P0_72_L, BIT(13), BIT(13));
2167 //MsOS_DelayTaskUs(1);
2168 W2BYTEMSK(REG_DVI_DTOP_DUAL_P0_72_L, 0, BIT(13));
2169
2170 MHAL_MHL_MSG_INFO("** MHL toggle ~~~\r\n");
2171 }
2172 }
2173 else // DE unstable
2174 {
2175 if(ucStableCount >= MHL_CDR_STABLE_THRESHOLD)
2176 {
2177 ucStableCount = 0;
2178 }
2179 else if(ucStableCount == (MHL_CDR_STABLE_THRESHOLD -1))
2180 {
2181 MHAL_MHL_MSG_INFO("** MHL time change toggle CDR mode\r\n");
2182
2183 ucStableCount = 0;
2184 }
2185 }
2186 }
2187 else
2188 {
2189 if(bPLLPower[ucCbusSelect])
2190 {
2191 bPLLPower[ucCbusSelect] = FALSE;
2192 ucStableCount = 0;
2193 }
2194 }
2195 }
2196 }
2197
2198 break;
2199 #endif
2200
2201 #if(MHL_FUNCTION_SUPPORT_PORTC)
2202 case MHL_CBUS_SELECT_PORTC:
2203 if(GET_MHL_PATH_SUPPORT_PORTC())
2204 {
2205 if(bPathEnable && (_mhal_mhl_CheckClockStatus(ucCbusSelect)))
2206 {
2207 if(ucStableCount < (MHL_CDR_FORCE_THRESHOLD +1))
2208 {
2209 ucStableCount++;
2210 }
2211
2212 if(!bPLLPower[ucCbusSelect])
2213 {
2214 bPLLPower[ucCbusSelect] = TRUE;
2215 }
2216
2217 if((R2BYTE(REG_DVI_DTOP_DUAL_P0_31_L) &BIT(6)) == BIT(6)) // DE stable
2218 {
2219 if(ucStableCount < MHL_CDR_STABLE_THRESHOLD)
2220 {
2221 ucStableCount = MHL_CDR_STABLE_THRESHOLD;
2222 }
2223 else if(ucStableCount == (MHL_CDR_FORCE_THRESHOLD -1))
2224 {
2225 W2BYTEMSK(REG_DVI_DTOP_DUAL_P0_72_L, BIT(13), BIT(13));
2226 //MsOS_DelayTaskUs(1);
2227 W2BYTEMSK(REG_DVI_DTOP_DUAL_P0_72_L, 0, BIT(13));
2228
2229 MHAL_MHL_MSG_INFO("** MHL toggle ~~~\r\n");
2230 }
2231 }
2232 else // DE unstable
2233 {
2234 if(ucStableCount >= MHL_CDR_STABLE_THRESHOLD)
2235 {
2236 ucStableCount = 0;
2237 }
2238 else if(ucStableCount == (MHL_CDR_STABLE_THRESHOLD -1))
2239 {
2240 //msg_mhl(printf("** MHL time change toggle CDR mode\r\n"));
2241
2242 ucStableCount = 0;
2243 }
2244 }
2245 }
2246 else
2247 {
2248 if(bPLLPower[ucCbusSelect])
2249 {
2250 bPLLPower[ucCbusSelect] = FALSE;
2251 ucStableCount = 0;
2252 }
2253 }
2254 }
2255
2256 break;
2257 #endif
2258
2259 #if(MHL_FUNCTION_SUPPORT_PORTD)
2260 case MHL_CBUS_SELECT_PORTD:
2261 if(GET_MHL_PATH_SUPPORT_PORTD())
2262 {
2263
2264 }
2265
2266 break;
2267 #endif
2268
2269 default:
2270 if(bPLLPower[0])
2271 {
2272
2273 }
2274
2275 break;
2276 };
2277
2278 if(ucStableCount >= MHL_CDR_FORCE_THRESHOLD)
2279 {
2280 bMHLSignalStable = TRUE;
2281 }
2282 else if(bMHLSignalStable)
2283 {
2284 bMHLSignalStable = FALSE;
2285 }
2286
2287 return bindex;
2288 }
2289
2290 //**************************************************************************
2291 // [Function Name]:
2292 // mhal_mhl_CbusIsolate()
2293 // [Description]
2294 // MHL cable isolate
2295 // [Arguments]:
2296 //
2297 // [Return]:
2298 //
2299 //**************************************************************************
mhal_mhl_CbusIsolate(MS_U8 ucCbusSelect,MS_BOOL bFlag)2300 void mhal_mhl_CbusIsolate(MS_U8 ucCbusSelect, MS_BOOL bFlag)
2301 {
2302 switch(ucCbusSelect)
2303 {
2304 #if(MHL_FUNCTION_SUPPORT_PORTA)
2305 case MHL_CBUS_SELECT_PORTA:
2306 if(GET_MHL_PATH_SUPPORT_PORTA())
2307 {
2308
2309 }
2310
2311 break;
2312 #endif
2313
2314 #if(MHL_FUNCTION_SUPPORT_PORTB)
2315 case MHL_CBUS_SELECT_PORTB:
2316 if(GET_MHL_PATH_SUPPORT_PORTB())
2317 {
2318 if(bFlag)
2319 {
2320 W2BYTEMSK(REG_PM_MHL_CBUS_00, BIT(9), BIT(9) | BIT(8));
2321 }
2322 else
2323 {
2324 W2BYTEMSK(REG_PM_MHL_CBUS_00, 0, BIT(9) | BIT(8));
2325 }
2326 }
2327
2328 break;
2329 #endif
2330
2331 #if(MHL_FUNCTION_SUPPORT_PORTC)
2332 case MHL_CBUS_SELECT_PORTC:
2333 if(GET_MHL_PATH_SUPPORT_PORTC())
2334 {
2335 if(bFlag)
2336 {
2337 W2BYTEMSK(REG_PM_MHL_CBUS_00, BIT(9), BIT(9) | BIT(8));
2338 }
2339 else
2340 {
2341 W2BYTEMSK(REG_PM_MHL_CBUS_00, 0, BIT(9) | BIT(8));
2342 }
2343 }
2344
2345 break;
2346 #endif
2347
2348 #if(MHL_FUNCTION_SUPPORT_PORTD)
2349 case MHL_CBUS_SELECT_PORTD:
2350 if(GET_MHL_PATH_SUPPORT_PORTD())
2351 {
2352
2353 }
2354
2355 break;
2356 #endif
2357
2358 default:
2359
2360 break;
2361 };
2362 }
2363
2364 //**************************************************************************
2365 // [Function Name]:
2366 // mhal_mhl_VbusCharge()
2367 // [Description]
2368 // MHL Vbus charge
2369 // [Arguments]:
2370 //
2371 // [Return]:
2372 //
2373 //**************************************************************************
mhal_mhl_VbusCharge(MS_U8 ucCbusSelect,MS_U8 bState)2374 void mhal_mhl_VbusCharge(MS_U8 ucCbusSelect, MS_U8 bState)
2375 {
2376 switch(ucCbusSelect)
2377 {
2378 #if(MHL_FUNCTION_SUPPORT_PORTA)
2379 case MHL_CBUS_SELECT_PORTA:
2380 if(GET_MHL_PATH_SUPPORT_PORTA())
2381 {
2382
2383 }
2384
2385 break;
2386 #endif
2387
2388 #if(MHL_FUNCTION_SUPPORT_PORTB)
2389 case MHL_CBUS_SELECT_PORTB:
2390 if(GET_MHL_PATH_SUPPORT_PORTB())
2391 {
2392 if(bState == VBUS_SW_CHARGE)
2393 {
2394 W2BYTEMSK(REG_PM_MHL_CBUS_01, BMASK(1:0), BMASK(1:0));
2395 }
2396 else if(bState == VBUS_SW_UNCHARGE)
2397 {
2398 W2BYTEMSK(REG_PM_MHL_CBUS_01, BIT(1), BMASK(1:0));
2399 }
2400 else
2401 {
2402 W2BYTEMSK(REG_PM_MHL_CBUS_01, 0, BMASK(1:0));
2403 }
2404 }
2405
2406 break;
2407 #endif
2408
2409 #if(MHL_FUNCTION_SUPPORT_PORTC)
2410 case MHL_CBUS_SELECT_PORTC:
2411 if(GET_MHL_PATH_SUPPORT_PORTC())
2412 {
2413 if(bState == VBUS_SW_CHARGE)
2414 {
2415 W2BYTEMSK(REG_PM_MHL_CBUS_01, BMASK(1:0), BMASK(1:0));
2416 }
2417 else if(bState == VBUS_SW_UNCHARGE)
2418 {
2419 W2BYTEMSK(REG_PM_MHL_CBUS_01, BIT(1), BMASK(1:0));
2420 }
2421 else
2422 {
2423 W2BYTEMSK(REG_PM_MHL_CBUS_01, 0, BMASK(1:0));
2424 }
2425 }
2426
2427 break;
2428 #endif
2429
2430 #if(MHL_FUNCTION_SUPPORT_PORTD)
2431 case MHL_CBUS_SELECT_PORTD:
2432 if(GET_MHL_PATH_SUPPORT_PORTD())
2433 {
2434
2435 }
2436
2437 break;
2438 #endif
2439
2440 default:
2441
2442 break;
2443 };
2444 }
2445
2446 //**************************************************************************
2447 // [Function Name]:
2448 // mhal_mhl_CbusFloating()
2449 // [Description]
2450 // MHL cable floating
2451 // [Arguments]:
2452 //
2453 // [Return]:
2454 //
2455 //**************************************************************************
mhal_mhl_CbusFloating(MS_BOOL bFlag)2456 void mhal_mhl_CbusFloating(MS_BOOL bFlag)
2457 {
2458 if(bFlag)
2459 {
2460 W2BYTEMSK(REG_PM_MHL_CBUS_17, BIT(5), BIT(5));
2461 }
2462 else
2463 {
2464 W2BYTEMSK(REG_PM_MHL_CBUS_17, 0, BIT(5));
2465 }
2466 }
2467
2468 //**************************************************************************
2469 // [Function Name]:
2470 // mhal_mhl_CbusStucktoLow()
2471 // [Description]
2472 //
2473 // [Arguments]:
2474 //
2475 // [Return]:
2476 //
2477 //**************************************************************************
mhal_mhl_CbusStucktoLow(MS_BOOL bFlag)2478 void mhal_mhl_CbusStucktoLow(MS_BOOL bFlag)
2479 {
2480 if(bFlag)
2481 {
2482 W2BYTEMSK(REG_PM_MHL_CBUS_18, 0, BIT(1)); // cbus stuck to low int mask
2483 }
2484 else
2485 {
2486 W2BYTEMSK(REG_PM_MHL_CBUS_18, BIT(1), BIT(1)); // cbus stuck to low int mask
2487 }
2488
2489 W2BYTEMSK(REG_PM_MHL_CBUS_18, BIT(0), BIT(0)); // Clear cbus stuck to low int flag
2490 }
2491
2492 //**************************************************************************
2493 // [Function Name]:
2494 // mhal_mhl_CbusWakeupInterrupt()
2495 // [Description]
2496 //
2497 // [Arguments]:
2498 //
2499 // [Return]:
2500 //
2501 //**************************************************************************
mhal_mhl_CbusWakeupInterrupt(MS_BOOL bFlag)2502 void mhal_mhl_CbusWakeupInterrupt(MS_BOOL bFlag)
2503 {
2504 if(bFlag)
2505 {
2506 W2BYTEMSK(REG_PM_MHL_CBUS_18, 0, BIT(5)); // wake up pulse int mask
2507 }
2508 else
2509 {
2510 W2BYTEMSK(REG_PM_MHL_CBUS_18, BIT(5), BIT(5)); // wake up pulse int mask
2511 }
2512
2513 W2BYTEMSK(REG_PM_MHL_CBUS_18, BIT(4), BIT(4)); // Clear wake up pulse int flag
2514 }
2515
2516 //**************************************************************************
2517 // [Function Name]:
2518 // mhal_mhl_SetVenderID()
2519 // [Description]
2520 //
2521 // [Arguments]:
2522 //
2523 // [Return]:
2524 //
2525 //**************************************************************************
mhal_mhl_SetVenderID(MS_U8 ucVenderID)2526 void mhal_mhl_SetVenderID(MS_U8 ucVenderID)
2527 {
2528 W2BYTEMSK(REG_MHL_CBUS_00, (ucVenderID << 8), BMASK(15:8));
2529 }
2530
2531 //**************************************************************************
2532 // [Function Name]:
2533 // mhal_mhl_LoadEDID()
2534 // [Description]
2535 //
2536 // [Arguments]:
2537 //
2538 // [Return]:
2539 //
2540 //**************************************************************************
mhal_mhl_LoadEDID(MS_U8 * edid)2541 void mhal_mhl_LoadEDID(MS_U8 *edid)
2542 {
2543 MS_U16 ustemp = 0;
2544
2545 if(edid != NULL)
2546 {
2547 // Load EDID
2548 MHAL_MHL_MSG_INFO("** Messi Load MHL EDID...\r\n");
2549
2550 W2BYTEMSK(REG_MHL_CBUS_52, BIT(1), BIT(1)); // CPU write enable
2551
2552 for(ustemp = 0; ustemp <256; ustemp++)
2553 {
2554 W2BYTEMSK(REG_MHL_CBUS_52, ustemp <<8, 0xFF00); // address
2555 W2BYTEMSK(REG_MHL_CBUS_53, edid[ustemp], 0x00FF); // data
2556 W2BYTEMSK(REG_MHL_CBUS_52, BIT(0), BIT(0)); // write trigger
2557 W2BYTEMSK(REG_MHL_CBUS_52, 0, BIT(0));
2558 while(R2BYTE(REG_MHL_CBUS_52) & BIT(5));
2559 }
2560
2561 W2BYTEMSK(REG_MHL_CBUS_52, 0, BIT(1)); // CPU write disable
2562 }
2563 }
2564
2565 //**************************************************************************
2566 // [Function Name]:
2567 // mhal_mhl_ReadEDID()
2568 // [Description]
2569 //
2570 // [Arguments]:
2571 //
2572 // [Return]:
2573 //
2574 //**************************************************************************
mhal_mhl_ReadEDID(MS_U16 usSize,MS_U8 * edid)2575 void mhal_mhl_ReadEDID(MS_U16 usSize, MS_U8 *edid)
2576 {
2577 MS_U16 ustemp = 0;
2578
2579 if(edid != NULL)
2580 {
2581 // Read EDID
2582 MHAL_MHL_MSG_INFO("** Messi Read MHL EDID...\r\n");
2583
2584 for(ustemp = 0; ustemp < usSize; ustemp++)
2585 {
2586 W2BYTEMSK(REG_MHL_CBUS_52, ustemp <<8, 0xFF00); // address
2587 W2BYTEMSK(REG_MHL_CBUS_52, BIT(3), BIT(3)); // read trigger
2588 W2BYTEMSK(REG_MHL_CBUS_52, 0, BIT(0));
2589 while(R2BYTE(REG_MHL_CBUS_52) & BIT(4));
2590
2591 edid[ustemp] = (MS_U8)((R2BYTE(REG_MHL_CBUS_53) & 0xFF00) >> 8); // data
2592 }
2593 }
2594 }
2595
2596 //**************************************************************************
2597 // [Function Name]:
2598 // mhal_mhl_LoadDeviceCapability()
2599 // [Description]
2600 //
2601 // [Arguments]:
2602 //
2603 // [Return]:
2604 //
2605 //**************************************************************************
mhal_mhl_LoadDeviceCapability(MS_U8 * devcap)2606 void mhal_mhl_LoadDeviceCapability(MS_U8 *devcap)
2607 {
2608 MS_U8 ucIndex = 0;
2609 MS_U8 uctemp = 0;
2610
2611 if(devcap != NULL)
2612 {
2613 MHAL_MHL_MSG_INFO("** Messi Load DevCap...\r\n");
2614
2615 // Load MHL device capability
2616 for(uctemp = 0; uctemp <8; uctemp++)
2617 {
2618 if(uctemp == 2)
2619 {
2620 ucIndex = 1;
2621 }
2622
2623 W2BYTE(REG_MHL_CBUS_01 +(uctemp *2), (devcap[(uctemp *2) +1 -ucIndex] <<8) | devcap[uctemp *2 -ucIndex]);
2624 }
2625
2626 W2BYTE(REG_MHL_CBUS_03, (devcap[3] <<8) | devcap[4]);
2627 W2BYTE(REG_MHL_CBUS_07, (devcap[11] <<8) | devcap[12]);
2628
2629 W2BYTEMSK(REG_MHL_CBUS_09, devcap[15], BMASK(7:0));
2630
2631 for(uctemp = 0; uctemp <2; uctemp++)
2632 {
2633 W2BYTE(REG_MHL_CBUS_19 +(uctemp *2), (devcap[(uctemp *2) +17] <<8) | devcap[(uctemp *2) +16]); // [15:0], MHL_ECBUS_SPEEDS
2634 }
2635 }
2636 }
2637
2638 //**************************************************************************
2639 // [Function Name]:
2640 // mhal_mhl_initial()
2641 // [Description]
2642 // MHL init
2643 // [Arguments]:
2644 // *edid: MHL EDID data
2645 // *devcap: MHL device capability
2646 // [Return]:
2647 //
2648 //**************************************************************************
mhal_mhl_initial(MS_U8 * edid,MS_U8 * devcap,MS_U8 ucVenderID)2649 MS_U8 mhal_mhl_initial(MS_U8 *edid, MS_U8 *devcap, MS_U8 ucVenderID)
2650 {
2651 MS_U8 ucCapability = MHL_CHIP_FUNCTION_CAPABILITY;
2652 MS_U16 uctemp = 0;
2653
2654 // Initial setting
2655 for(uctemp = 0; uctemp <(sizeof(tMHL_INITIAL_TABLE) /sizeof(msLoadTbl_S)); uctemp++)
2656 {
2657 W2BYTEMSK(tMHL_INITIAL_TABLE[uctemp].addr, tMHL_INITIAL_TABLE[uctemp].databuf, tMHL_INITIAL_TABLE[uctemp].mask);
2658 }
2659
2660 // ECbus initial setting
2661 _mhal_mhl_ECbusInitialSetting();
2662
2663 // Load EDID
2664 mhal_mhl_LoadEDID(edid);
2665
2666 // Load vendor ID
2667 mhal_mhl_SetVenderID(ucVenderID);
2668
2669 // Load DevCap
2670 mhal_mhl_LoadDeviceCapability(devcap);
2671
2672 // Clear Cbus received interrupt status
2673 W2BYTEMSK(REG_MHL_CBUS_3A, BIT(4)|BIT(0), BIT(4)|BIT(1)|BIT(0)); // [1]: receive packet valid mask
2674
2675 mhal_mhl_CbusStucktoLow(FALSE);
2676 mhal_mhl_CbusWakeupInterrupt(FALSE);
2677
2678 _mhal_mhl_MHLForceToAttach();
2679
2680 for(uctemp = 0; uctemp < MHL_CBUS_SELECT_MASK; uctemp++)
2681 {
2682 _mhal_mhl_RtermHWControl(uctemp, FALSE);
2683 }
2684
2685 _mhal_mhl_ForcePullDown100K(TRUE);
2686
2687 mhal_mhl_CbusFloating(TRUE);
2688
2689 if(GET_MHL_PATH_SUPPORT_PORTB()) // Port B not support MHL 3.0
2690 {
2691 ucCapability = ucCapability &(~(BIT(2)));
2692 }
2693
2694 return ucCapability;
2695 }
2696
2697 //**************************************************************************
2698 // [Function Name]:
2699 // mhal_mhl_InvertCableDetect()
2700 // [Description]
2701 //
2702 // [Arguments]:
2703 //
2704 // [Return]:
2705 //
2706 //**************************************************************************
mhal_mhl_InvertCableDetect(MS_U8 ucCbusSelect,MS_BOOL bCableDetectInvert)2707 void mhal_mhl_InvertCableDetect(MS_U8 ucCbusSelect, MS_BOOL bCableDetectInvert)
2708 {
2709 switch(ucCbusSelect)
2710 {
2711 #if(MHL_FUNCTION_SUPPORT_PORTA)
2712 case MHL_CBUS_SELECT_PORTA:
2713 if(GET_MHL_PATH_SUPPORT_PORTA())
2714 {
2715
2716 }
2717
2718 break;
2719 #endif
2720
2721 #if(MHL_FUNCTION_SUPPORT_PORTB)
2722 case MHL_CBUS_SELECT_PORTB:
2723 if(GET_MHL_PATH_SUPPORT_PORTB())
2724 {
2725 W2BYTEMSK(REG_PM_MHL_CBUS_00, bCableDetectInvert? BIT(11): 0, BIT(11));
2726 }
2727
2728 break;
2729 #endif
2730
2731 #if(MHL_FUNCTION_SUPPORT_PORTC)
2732 case MHL_CBUS_SELECT_PORTC:
2733 if(GET_MHL_PATH_SUPPORT_PORTC())
2734 {
2735 W2BYTEMSK(REG_PM_MHL_CBUS_00, bCableDetectInvert? BIT(11): 0, BIT(11));
2736 }
2737
2738 break;
2739 #endif
2740
2741 #if(MHL_FUNCTION_SUPPORT_PORTD)
2742 case MHL_CBUS_SELECT_PORTD:
2743 if(GET_MHL_PATH_SUPPORT_PORTD())
2744 {
2745
2746 }
2747
2748 break;
2749 #endif
2750
2751 default:
2752
2753 break;
2754 };
2755 }
2756
2757 //**************************************************************************
2758 // [Function Name]:
2759 // mhal_mhl_VbusConfigSetting()
2760 // [Description]
2761 //
2762 // [Arguments]:
2763 //
2764 // [Return]:
2765 //
2766 //**************************************************************************
mhal_mhl_VbusConfigSetting(MS_U8 ucCbusSelect,MS_U8 ucState)2767 void mhal_mhl_VbusConfigSetting(MS_U8 ucCbusSelect, MS_U8 ucState)
2768 {
2769 MS_U8 ucOutputState = ucState &(MHL_VBUS_LOW_ENABLE_MODE | MHL_VBUS_HIGH_ENABLE_MODE);
2770
2771 ucState = ucState &(MHL_VBUS_OUTPUT_MODE | MHL_VBUS_INVERSE_MODE);
2772
2773 switch(ucCbusSelect)
2774 {
2775 #if(MHL_FUNCTION_SUPPORT_PORTA)
2776 case MHL_CBUS_SELECT_PORTA:
2777 if(GET_MHL_PATH_SUPPORT_PORTA())
2778 {
2779
2780 }
2781
2782 break;
2783 #endif
2784
2785 #if(MHL_FUNCTION_SUPPORT_PORTB)
2786 case MHL_CBUS_SELECT_PORTB:
2787 if(GET_MHL_PATH_SUPPORT_PORTB())
2788 {
2789 if(ucState == MHL_VBUS_OUTPUT_MODE)
2790 {
2791 W2BYTEMSK(REG_PM_MHL_CBUS_31, BIT(0), BIT(0));
2792 W2BYTEMSK(REG_PM_MHL_CBUS_21, BIT(7), BIT(7));
2793 }
2794 else if(ucState > 0)
2795 {
2796 W2BYTEMSK(REG_PM_MHL_CBUS_31, BIT(0), BIT(0));
2797 }
2798
2799 if(ucOutputState > 0)
2800 {
2801 if(ucOutputState == MHL_VBUS_HIGH_ENABLE_MODE)
2802 {
2803 W2BYTEMSK(REG_PM_MHL_CBUS_20, 0, BMASK(9:8));
2804 }
2805 else
2806 {
2807 W2BYTEMSK(REG_PM_MHL_CBUS_20, BIT(9), BMASK(9:8));
2808 }
2809 }
2810 }
2811
2812 break;
2813 #endif
2814
2815 #if(MHL_FUNCTION_SUPPORT_PORTC)
2816 case MHL_CBUS_SELECT_PORTC:
2817 if(GET_MHL_PATH_SUPPORT_PORTC())
2818 {
2819 if(ucState == MHL_VBUS_OUTPUT_MODE)
2820 {
2821 W2BYTEMSK(REG_PM_MHL_CBUS_31, BIT(0), BIT(0));
2822 W2BYTEMSK(REG_PM_MHL_CBUS_21, BIT(7), BIT(7));
2823 }
2824 else if(ucState > 0)
2825 {
2826 W2BYTEMSK(REG_PM_MHL_CBUS_31, BIT(0), BIT(0));
2827 }
2828
2829 if(ucOutputState > 0)
2830 {
2831 if(ucOutputState == MHL_VBUS_HIGH_ENABLE_MODE)
2832 {
2833 W2BYTEMSK(REG_PM_MHL_CBUS_20, 0, BMASK(9:8));
2834 }
2835 else
2836 {
2837 W2BYTEMSK(REG_PM_MHL_CBUS_20, BIT(9), BMASK(9:8));
2838 }
2839 }
2840 }
2841
2842 break;
2843 #endif
2844
2845 #if(MHL_FUNCTION_SUPPORT_PORTD)
2846 case MHL_CBUS_SELECT_PORTD:
2847 if(GET_MHL_PATH_SUPPORT_PORTD())
2848 {
2849
2850 }
2851
2852 break;
2853 #endif
2854
2855 default:
2856
2857 break;
2858 };
2859
2860 ucOutputState = 0;
2861 }
2862
2863 //**************************************************************************
2864 // [Function Name]:
2865 // mhal_mhl_CableDetectPadSetting()
2866 // [Description]
2867 //
2868 // [Arguments]:
2869 //
2870 // [Return]:
2871 //
2872 //**************************************************************************
mhal_mhl_CableDetectPadSetting(MS_U8 ucSelect)2873 void mhal_mhl_CableDetectPadSetting(MS_U8 ucSelect)
2874 {
2875 if(ucSelect &MHL_CABLE_DETECT_SELECT_PORTB)
2876 {
2877 // Do nothing
2878 }
2879 }
2880
2881 //**************************************************************************
2882 // [Function Name]:
2883 // mhal_mhl_CbusPadConfigSwitch()
2884 // [Description]
2885 //
2886 // [Arguments]:
2887 //
2888 // [Return]:
2889 //
2890 //**************************************************************************
mhal_mhl_CbusPadConfigSwitch(MS_U8 ucCbusSelect,MS_BOOL bFlag)2891 void mhal_mhl_CbusPadConfigSwitch(MS_U8 ucCbusSelect, MS_BOOL bFlag)
2892 {
2893 switch(ucCbusSelect)
2894 {
2895 #if(MHL_FUNCTION_SUPPORT_PORTA)
2896 case MHL_CBUS_SELECT_PORTA:
2897 if(GET_MHL_PATH_SUPPORT_PORTA())
2898 {
2899
2900 }
2901
2902 break;
2903 #endif
2904
2905 #if(MHL_FUNCTION_SUPPORT_PORTB)
2906 case MHL_CBUS_SELECT_PORTB:
2907 if(GET_MHL_PATH_SUPPORT_PORTB())
2908 {
2909 if(bFlag)
2910 {
2911 _mhal_mhl_MHLForceToAttach();
2912 mhal_mhl_VbusCharge(ucCbusSelect, VBUS_HW_DETECT);
2913 }
2914 else
2915 {
2916 _mhal_mhl_CbusForceToStandby();
2917 mhal_mhl_VbusCharge(ucCbusSelect, VBUS_SW_UNCHARGE);
2918 }
2919 }
2920
2921 break;
2922 #endif
2923
2924 #if(MHL_FUNCTION_SUPPORT_PORTC)
2925 case MHL_CBUS_SELECT_PORTC:
2926 if(GET_MHL_PATH_SUPPORT_PORTC())
2927 {
2928 if(bFlag)
2929 {
2930 _mhal_mhl_MHLForceToAttach();
2931 mhal_mhl_VbusCharge(ucCbusSelect, VBUS_HW_DETECT);
2932 }
2933 else
2934 {
2935 _mhal_mhl_CbusForceToStandby();
2936 mhal_mhl_VbusCharge(ucCbusSelect, VBUS_SW_UNCHARGE);
2937 }
2938 }
2939
2940 break;
2941 #endif
2942
2943 #if(MHL_FUNCTION_SUPPORT_PORTD)
2944 case MHL_CBUS_SELECT_PORTD:
2945 if(GET_MHL_PATH_SUPPORT_PORTD())
2946 {
2947
2948 }
2949
2950 break;
2951 #endif
2952
2953 default:
2954
2955 break;
2956 };
2957 }
2958
2959 //**************************************************************************
2960 // [Function Name]:
2961 // _mhal_mhl_CbusStatus()
2962 // [Description]:
2963 // MHL Cbus status
2964 // [Arguments]:
2965 //
2966 // [Return]:
2967 // Cbus status value
2968 //**************************************************************************
mhal_mhl_CbusStatus(void)2969 MS_U16 mhal_mhl_CbusStatus(void)
2970 {
2971 return (R2BYTE(REG_PM_MHL_CBUS_17));
2972 }
2973
2974 //**************************************************************************
2975 // [Function Name]:
2976 // mhal_mhl_CbusIsMscMsgReceived()
2977 // [Description]
2978 // MHL Cbus check whether msc message is received or not
2979 // [Arguments]:
2980 //
2981 // [Return]:
2982 // TRUE: recieved
2983 // FALSE: not yet
2984 //**************************************************************************
mhal_mhl_CbusIsMscMsgReceived(void)2985 MS_BOOL mhal_mhl_CbusIsMscMsgReceived(void)
2986 {
2987 MS_BOOL bindex = ((R2BYTE(REG_MHL_CBUS_3A) &BIT(3)) ?TRUE: FALSE);
2988
2989 if(bindex)
2990 {
2991 W2BYTEMSK(REG_MHL_CBUS_3A, BIT(0), BIT(0));
2992 }
2993
2994 return bindex;
2995 }
2996
2997 //**************************************************************************
2998 // [Function Name]:
2999 // mhal_mhl_CbusStucktoLowFlag()
3000 // [Description]
3001 //
3002 // [Arguments]:
3003 //
3004 // [Return]:
3005 //
3006 //**************************************************************************
mhal_mhl_CbusStucktoLowFlag(void)3007 MS_BOOL mhal_mhl_CbusStucktoLowFlag(void)
3008 {
3009 MS_BOOL bindex = ((R2BYTE(REG_PM_MHL_CBUS_18) &BIT(3)) ?TRUE: FALSE);
3010
3011 if(bindex)
3012 {
3013 W2BYTEMSK(REG_PM_MHL_CBUS_18, BIT(0), BIT(0));
3014 }
3015
3016 return bindex;
3017 }
3018
3019 //**************************************************************************
3020 // [Function Name]:
3021 // mhal_mhl_CbusWakeupIntFlag()
3022 // [Description]
3023 //
3024 // [Arguments]:
3025 //
3026 // [Return]:
3027 //
3028 //**************************************************************************
mhal_mhl_CbusWakeupIntFlag(void)3029 MS_BOOL mhal_mhl_CbusWakeupIntFlag(void)
3030 {
3031 MS_BOOL bindex = ((R2BYTE(REG_PM_MHL_CBUS_18) &BIT(7)) ?TRUE: FALSE);
3032
3033 if(bindex)
3034 {
3035 W2BYTEMSK(REG_PM_MHL_CBUS_18, BIT(4), BIT(4));
3036 }
3037
3038 return bindex;
3039 }
3040
3041 //**************************************************************************
3042 // [Function Name]:
3043 // mhal_mhl_GetECbusStateChangeFlag()
3044 // [Description]
3045 //
3046 // [Arguments]:
3047 //
3048 // [Return]:
3049 //
3050 //**************************************************************************
mhal_mhl_GetECbusStateChangeFlag(void)3051 MS_BOOL mhal_mhl_GetECbusStateChangeFlag(void)
3052 {
3053 MS_BOOL bindex = ((R2BYTE(REG_MHL_ECBUS_3A) &BIT(0)) ?TRUE: FALSE);
3054
3055 if(bindex)
3056 {
3057 W2BYTEMSK(REG_MHL_ECBUS_34, BIT(0), BIT(0));
3058
3059 _mhal_mhl_ECbusStateChangeProc();
3060 }
3061
3062 return bindex;
3063 }
3064
3065 //**************************************************************************
3066 // [Function Name]:
3067 // mhal_mhl_GetEMSCReceiveFlag()
3068 // [Description]
3069 //
3070 // [Arguments]:
3071 //
3072 // [Return]:
3073 //
3074 //**************************************************************************
mhal_mhl_GetEMSCReceiveFlag(void)3075 MS_BOOL mhal_mhl_GetEMSCReceiveFlag(void)
3076 {
3077 MS_BOOL bindex = ((R2BYTE(REG_MHL_ECBUS_3A) &BIT(12)) ?TRUE: FALSE);
3078
3079 if(bindex)
3080 {
3081 W2BYTEMSK(REG_MHL_ECBUS_34, BIT(12), BIT(12));
3082 }
3083
3084 return bindex;
3085 }
3086
3087 //**************************************************************************
3088 // [Function Name]:
3089 // mhal_mhl_GetEMSCSendStatus()
3090 // [Description]
3091 //
3092 // [Arguments]:
3093 //
3094 // [Return]:
3095 //
3096 //**************************************************************************
mhal_mhl_GetEMSCSendStatus(void)3097 MS_U8 mhal_mhl_GetEMSCSendStatus(void)
3098 {
3099 MS_U8 ucSendStatus = MHL_EMSC_SEND_NONE;
3100
3101 if(R2BYTE(REG_MHL_ECBUS_3A) &BIT(10)) // eMSC send pass interrupt.
3102 {
3103 W2BYTEMSK(REG_MHL_ECBUS_34, BIT(10), BIT(10)); // eMSC send pass clear
3104
3105 ucSendStatus = MHL_EMSC_SEND_PASS;
3106 }
3107 else if(R2BYTE(REG_MHL_ECBUS_3A) &BIT(9)) // eMSC send fail interrupt.
3108 {
3109 W2BYTEMSK(REG_MHL_ECBUS_34, BIT(9), BIT(9)); // eMSC send fail clear
3110
3111 ucSendStatus = MHL_EMSC_SEND_FAIL;
3112 }
3113
3114 return ucSendStatus;
3115 }
3116
3117 //**************************************************************************
3118 // [Function Name]:
3119 // mhal_mhl_CBusWrite()
3120 // [Description]
3121 // MHL Cbus write trigger
3122 // [Arguments]:
3123 // *pdatabuf: Cbus tx data
3124 // [Return]:
3125 //
3126 //**************************************************************************
mhal_mhl_CBusWrite(mhalCbusFifo_S * pdatabuf)3127 MS_BOOL mhal_mhl_CBusWrite(mhalCbusFifo_S *pdatabuf)
3128 {
3129 MS_U8 uctemp = 0;
3130
3131 if(_mhal_mhl_IsCbusBusy())
3132 {
3133 return FALSE;
3134 }
3135
3136 for(uctemp = 0; uctemp < pdatabuf->lens; uctemp++)
3137 {
3138 W2BYTE(REG_MHL_CBUS_26 +uctemp *2, pdatabuf->databuf[uctemp]);
3139 }
3140
3141 // clear the unsed parts
3142 W2BYTE(REG_MHL_CBUS_26 +((pdatabuf->lens) *2), 0);
3143
3144 W2BYTEMSK(REG_MHL_CBUS_25, BIT(12), BIT(12)); // trigger to send
3145
3146 #if(MHL_DEBUG_SEND_MSC)
3147 for(uctemp = 0; uctemp < pdatabuf->lens; uctemp++)
3148 {
3149 if((pdatabuf->databuf[uctemp]) &BIT(8))
3150 {
3151 MHAL_MHL_MSG_DEBUG(" MHL send MSG command = %x\r\n", (pdatabuf->databuf[uctemp] &BMASK(7:0)));
3152 }
3153 else
3154 {
3155 MHAL_MHL_MSG_DEBUG(" MHL send MSG data = %x\r\n", (pdatabuf->databuf[uctemp] &BMASK(7:0)));
3156 }
3157 }
3158
3159 #endif
3160
3161 return TRUE;
3162 }
3163
3164 //**************************************************************************
3165 // [Function Name]:
3166 // _mhal_mhl_Cbus_SetPathEn()
3167 // [Description]:
3168 // MHL Cbus set path enable
3169 // [Arguments]:
3170 // TRUE: Enable
3171 // FALSE: Disable
3172 // [Return]:
3173 //
3174 //**************************************************************************
mhal_mhl_Cbus_SetPathEn(MS_BOOL bflag)3175 void mhal_mhl_Cbus_SetPathEn(MS_BOOL bflag)
3176 {
3177 if(bflag) // set state to PATH_EN
3178 {
3179 W2BYTEMSK(REG_PM_MHL_CBUS_17, BIT(12), BIT(12));
3180 }
3181 else // clear state to not PATH_EN
3182 {
3183 W2BYTEMSK(REG_PM_MHL_CBUS_17, BIT(13), BIT(13));
3184 }
3185 }
3186
3187 //**************************************************************************
3188 // [Function Name]:
3189 // mhal_mhl_CbusIntCB()
3190 // [Description]
3191 // MHL Cbus Interrupt Call Back function
3192 // [Arguments]:
3193 // *rcstate: recevied state, 0:normal / 1:timeout
3194 // *rccmd: recevied command
3195 // *rcdata: recevied data
3196 // *rclen: received length
3197 // *bIsCmdInData: Is command in data field
3198 // [Return]:
3199 //
3200 //**************************************************************************
mhal_mhl_CbusIntCB(MS_U8 * rcstate,MS_U8 * rccmd,MS_U8 * rcdata,MS_U8 * rclen,MS_U8 * bIsCmdInData)3201 MS_BOOL mhal_mhl_CbusIntCB(MS_U8 *rcstate, MS_U8 *rccmd, MS_U8 *rcdata, MS_U8 *rclen, MS_U8 *bIsCmdInData)
3202 {
3203 MS_BOOL bindex = FALSE;
3204 MS_U8 uctemp = 0;
3205 MS_U16 reg_val;
3206
3207 *rcstate = R2BYTE(REG_MHL_CBUS_3B) & 0x000F; // received state, 0: normal, 1: timeout
3208
3209 //W2BYTEMSK(REG_MHL_CBUS_3A, BIT(0), BIT(0)); // clear INT
3210
3211 reg_val = R2BYTE(REG_MHL_CBUS_3C);
3212
3213 if(!(reg_val &BIT(8))) // Received data
3214 {
3215 bindex = TRUE;
3216 }
3217
3218 *rccmd = reg_val & 0x00FF;
3219 *bIsCmdInData = FALSE;
3220
3221 for(uctemp = 0; uctemp <=(MHL_CBUS_DATA_SIZE +1); uctemp++) // offset+16bytes+EOF
3222 {
3223 reg_val = R2BYTE(REG_MHL_CBUS_3D +(uctemp *2));
3224
3225 if(reg_val & BIT(15))
3226 {
3227 rcdata[uctemp] = reg_val & 0x00FF;
3228
3229 if(((uctemp <= 2) ||(uctemp == (MHL_CBUS_DATA_SIZE +1))) && !(*bIsCmdInData))
3230 {
3231 *bIsCmdInData = (reg_val & BIT(8)) ? TRUE : FALSE;
3232 }
3233 }
3234 else
3235 {
3236 *rclen = uctemp;
3237 break;
3238 }
3239 }
3240
3241 // CTS 6.3.11.19
3242 if(uctemp >(MHL_CBUS_DATA_SIZE +1))
3243 {
3244 *rclen = MHL_CBUS_DATA_SIZE +2;
3245 }
3246
3247 W2BYTEMSK(REG_MHL_CBUS_3A, BIT(4), BIT(4)); // clear received FIFO
3248
3249 return bindex;
3250 }
3251
3252 //**************************************************************************
3253 // [Function Name]:
3254 // mdrv_mhl_CBusCheckBCHError()
3255 // [Description]:
3256 // MHL Cbus check BCH error
3257 // [Arguments]:
3258 //
3259 // [Return]:
3260 //
3261 //**************************************************************************
mhal_mhl_CBusCheckBCHError(void)3262 MS_BOOL mhal_mhl_CBusCheckBCHError(void)
3263 {
3264 MS_BOOL bindex = FALSE;
3265
3266 return bindex;
3267 }
3268
3269 //**************************************************************************
3270 // [Function Name]:
3271 // mhal_mhl_CablePlugProc()
3272 // [Description]
3273 //
3274 // [Arguments]:
3275 //
3276 // [Return]:
3277 //
3278 //**************************************************************************
mhal_mhl_CablePlugProc(MS_U8 ucCbusSelect)3279 void mhal_mhl_CablePlugProc(MS_U8 ucCbusSelect)
3280 {
3281 if(mhal_mhl_CheckInputPort(ucCbusSelect))
3282 {
3283 _mhal_mhl_Mhl24bitsModeSetting(ucCbusSelect);
3284
3285 _mhal_mhl_ForcePullDown100K(FALSE);
3286 }
3287
3288 _mhal_mhl_RxRtermControl(ucCbusSelect, RX_RTERM_OFF);
3289
3290 _mhal_mhl_AdjustCommonModeResistor(ucCbusSelect, TRUE);
3291 }
3292
3293 //**************************************************************************
3294 // [Function Name]:
3295 // mhal_mhl_CableRemoveProc()
3296 // [Description]
3297 //
3298 // [Arguments]:
3299 //
3300 // [Return]:
3301 //
3302 //**************************************************************************
mhal_mhl_CableRemoveProc(MS_U8 ucCbusSelect)3303 void mhal_mhl_CableRemoveProc(MS_U8 ucCbusSelect)
3304 {
3305 // Disable ECbus state change IRQ
3306 _mhal_mhl_SetECbusStateChangeInterrupt(FALSE);
3307 // Disable eMSC receive IRQ
3308 _mhal_mhl_SetEMSCReceiveInterrupt(FALSE);
3309
3310 if(mhal_mhl_CheckInputPort(ucCbusSelect))
3311 {
3312 _mhal_mhl_HdmiBypassModeSetting(ucCbusSelect);
3313
3314 _mhal_mhl_ForcePullDown100K(TRUE);
3315
3316 _mhal_mhl_Version3PhyEnable(ucCbusSelect, FALSE);
3317 }
3318
3319 // Disable ECbus
3320 _mhal_mhl_ECbusEnableSetting(FALSE);
3321 // Set short read address to 0x08
3322 _mhal_mhl_SetShortReadAddress(FALSE);
3323
3324 _mhal_mhl_RxRtermControl(ucCbusSelect, RX_HDMI_RTERM);
3325
3326 ucMHL3LinkRate = MHL_AV_LINK_NONE;
3327 }
3328
3329 //**************************************************************************
3330 // [Function Name]:
3331 // mhal_mhl_CbusConnectProc()
3332 // [Description]
3333 //
3334 // [Arguments]:
3335 //
3336 // [Return]:
3337 //
3338 //**************************************************************************
mhal_mhl_CbusConnectProc(MS_U8 ucCbusSelect)3339 void mhal_mhl_CbusConnectProc(MS_U8 ucCbusSelect)
3340 {
3341 _mhal_mhl_RxRtermControl(ucCbusSelect, RX_MHL_RTERM);
3342
3343 if(mhal_mhl_CheckInputPort(ucCbusSelect))
3344 {
3345 _mhal_mhl_AdjustCommonModeResistor(ucCbusSelect, FALSE);
3346 }
3347
3348 mhal_mhl_CbusStucktoLow(TRUE);
3349 }
3350
3351 //**************************************************************************
3352 // [Function Name]:
3353 // mhal_mhl_CbusStucktoLowProc()
3354 // [Description]
3355 //
3356 // [Arguments]:
3357 //
3358 // [Return]:
3359 //
3360 //**************************************************************************
mhal_mhl_CbusStucktoLowProc(MS_U8 ucCbusSelect)3361 void mhal_mhl_CbusStucktoLowProc(MS_U8 ucCbusSelect)
3362 {
3363 _mhal_mhl_RxRtermControl(ucCbusSelect, RX_RTERM_OFF);
3364
3365 _mhal_mhl_AdjustCommonModeResistor(ucCbusSelect, TRUE);
3366
3367 mhal_mhl_CDRModeMonitor(ucCbusSelect, FALSE);
3368 // Set short read address to 0x08
3369 _mhal_mhl_SetShortReadAddress(FALSE);
3370
3371 ucMHL3LinkRate = MHL_AV_LINK_NONE;
3372 }
3373
3374 //**************************************************************************
3375 // [Function Name]:
3376 // mhal_mhl_SourceChangeProc()
3377 // [Description]
3378 //
3379 // [Arguments]:
3380 //
3381 // [Return]:
3382 //
3383 //**************************************************************************
mhal_mhl_SourceChangeProc(MS_U8 ucCbusSelect)3384 void mhal_mhl_SourceChangeProc(MS_U8 ucCbusSelect)
3385 {
3386 if(mhal_mhl_CheckInputPort(ucCbusSelect))
3387 {
3388 _mhal_mhl_Mhl24bitsModeSetting(ucCbusSelect);
3389
3390 if(mhal_mhl_CbusStatus() != 0x03)
3391 {
3392 _mhal_mhl_AdjustCommonModeResistor(ucCbusSelect, TRUE);
3393 }
3394 else
3395 {
3396 _mhal_mhl_AdjustCommonModeResistor(ucCbusSelect, FALSE);
3397 }
3398
3399 if(ucMHL3LinkRate != MHL_AV_LINK_NONE)
3400 {
3401 mhal_mhl_SetMainLinkRate(ucCbusSelect, ucMHL3LinkRate);
3402 }
3403 }
3404 else
3405 {
3406 _mhal_mhl_HdmiBypassModeSetting(ucCbusSelect);
3407
3408 _mhal_mhl_AdjustCommonModeResistor(ucCbusSelect, TRUE);
3409
3410 _mhal_mhl_Version3PhyEnable(ucCbusSelect, FALSE);
3411 }
3412 }
3413
3414 //**************************************************************************
3415 // [Function Name]:
3416 // mhal_mhl_ClockModeSwitchProc()
3417 // [Description]
3418 //
3419 // [Arguments]:
3420 //
3421 // [Return]:
3422 //
3423 //**************************************************************************
mhal_mhl_ClockModeSwitchProc(MS_U8 ucCbusSelect,MS_BOOL bPPmode)3424 void mhal_mhl_ClockModeSwitchProc(MS_U8 ucCbusSelect, MS_BOOL bPPmode)
3425 {
3426 if(mhal_mhl_CheckInputPort(ucCbusSelect))
3427 {
3428 if(bPPmode)
3429 {
3430 _mhal_mhl_MhlPackedPixelModeSetting(ucCbusSelect);
3431 }
3432 else
3433 {
3434 _mhal_mhl_Mhl24bitsModeSetting(ucCbusSelect);
3435 }
3436 }
3437 }
3438
3439 //**************************************************************************
3440 // [Function Name]:
3441 // mhal_mhl_CbusWakeupIntSetting()
3442 // [Description]
3443 //
3444 // [Arguments]:
3445 //
3446 // [Return]:
3447 //
3448 //**************************************************************************
mhal_mhl_CbusWakeupIntSetting(MS_U8 ucCbusSelect,MS_BOOL bFlag)3449 void mhal_mhl_CbusWakeupIntSetting(MS_U8 ucCbusSelect, MS_BOOL bFlag)
3450 {
3451 if(bFlag)
3452 {
3453 _mhal_mhl_CbusForceToStandby();
3454 mhal_mhl_CbusWakeupInterrupt(TRUE);
3455 mhal_mhl_VbusCharge(ucCbusSelect, VBUS_SW_CHARGE);
3456 }
3457 else
3458 {
3459 _mhal_mhl_MHLForceToAttach();
3460 mhal_mhl_CbusWakeupInterrupt(FALSE);
3461 mhal_mhl_VbusCharge(ucCbusSelect, VBUS_HW_DETECT);
3462 }
3463 }
3464
3465 //**************************************************************************
3466 // [Function Name]:
3467 // mhal_mhl_RtermControlHWMode()
3468 // [Description]
3469 //
3470 // [Arguments]:
3471 //
3472 // [Return]:
3473 //
3474 //**************************************************************************
mhal_mhl_RtermControlHWMode(MS_U8 ucCbusSelect,MS_BOOL bFlag)3475 void mhal_mhl_RtermControlHWMode(MS_U8 ucCbusSelect, MS_BOOL bFlag)
3476 {
3477 MS_U16 ustemp = mhal_mhl_CbusStatus();
3478
3479 if(!bFlag) // HW to SW control rterm
3480 {
3481 if((ustemp & BMASK(1:0)) == 0x03)
3482 {
3483 _mhal_mhl_RxRtermControl(ucCbusSelect, RX_MHL_RTERM);
3484 }
3485 else
3486 {
3487 _mhal_mhl_RxRtermControl(ucCbusSelect, RX_RTERM_OFF);
3488 }
3489 }
3490
3491 _mhal_mhl_RtermHWControl(ucCbusSelect, bFlag);
3492 }
3493
3494 //**************************************************************************
3495 // [Function Name]:
3496 // mhal_mhl_AdjustSettingIControl()
3497 // [Description]
3498 //
3499 // [Arguments]:
3500 //
3501 // [Return]:
3502 //
3503 //**************************************************************************
mhal_mhl_AdjustSettingIControl(MS_U8 ucIControl)3504 void mhal_mhl_AdjustSettingIControl(MS_U8 ucIControl)
3505 {
3506 ucIControlValue = ucIControl;
3507 }
3508
3509 //**************************************************************************
3510 // [Function Name]:
3511 // mhal_mhl_AdjustImpedanceSetting()
3512 // [Description]
3513 //
3514 // [Arguments]:
3515 //
3516 // [Return]:
3517 //
3518 //**************************************************************************
mhal_mhl_AdjustImpedanceSetting(MS_U8 ucImpedance)3519 void mhal_mhl_AdjustImpedanceSetting(MS_U8 ucImpedance)
3520 {
3521 ucImpedanceValue = ucImpedance;
3522 }
3523
3524 //**************************************************************************
3525 // [Function Name]:
3526 // mhal_mhl_GetSignalStableFlag()
3527 // [Description]
3528 //
3529 // [Arguments]:
3530 //
3531 // [Return]:
3532 //
3533 //**************************************************************************
mhal_mhl_GetSignalStableFlag(void)3534 MS_BOOL mhal_mhl_GetSignalStableFlag(void)
3535 {
3536 return bMHLSignalStable;
3537 }
3538
3539 //**************************************************************************
3540 // [Function Name]:
3541 // mhal_mhl_PowerControl()
3542 // [Description]
3543 // MHL power control
3544 // [Arguments]:
3545 //
3546 // [Return]:
3547 //
3548 //**************************************************************************
mhal_mhl_LoadPowerOnTbl(void)3549 void mhal_mhl_LoadPowerOnTbl(void)
3550 {
3551 MS_U8 uctemp = 0;
3552
3553 for(uctemp = 0; uctemp <(sizeof(tMHL_POWER_ON_TABLE) /sizeof(msLoadTbl_S)); uctemp++)
3554 {
3555 W2BYTEMSK(tMHL_POWER_ON_TABLE[uctemp].addr, tMHL_POWER_ON_TABLE[uctemp].databuf, tMHL_POWER_ON_TABLE[uctemp].mask);
3556 }
3557
3558 for(uctemp = 0; uctemp < MHL_CBUS_SELECT_MASK; uctemp++)
3559 {
3560 _mhal_mhl_RxRtermControl(uctemp, RX_HDMI_RTERM);
3561 }
3562 }
3563
mhal_mhl_LoadPowerStandbyTbl(void)3564 void mhal_mhl_LoadPowerStandbyTbl(void)
3565 {
3566 MS_U8 uctemp = 0;
3567
3568 //_mhal_mhl_CbusForceToStandby();
3569
3570 for(uctemp = 0; uctemp <(sizeof(tMHL_POWER_SAVING_TABLE) /sizeof(msLoadTbl_S)); uctemp++)
3571 {
3572 W2BYTEMSK(tMHL_POWER_SAVING_TABLE[uctemp].addr, tMHL_POWER_SAVING_TABLE[uctemp].databuf, tMHL_POWER_SAVING_TABLE[uctemp].mask);
3573 }
3574
3575 for(uctemp = 0; uctemp < MHL_CBUS_SELECT_MASK; uctemp++)
3576 {
3577 _mhal_mhl_RxRtermControl(uctemp, RX_RTERM_OFF);
3578 mhal_mhl_VbusCharge(uctemp, VBUS_SW_CHARGE);
3579 }
3580 }
3581
mhal_mhl_LoadPowerDownTbl(void)3582 void mhal_mhl_LoadPowerDownTbl(void)
3583 {
3584 MS_U8 uctemp = 0;
3585
3586 //_mhal_mhl_CbusForceToStandby();
3587
3588 for(uctemp = 0; uctemp <(sizeof(tMHL_POWER_DOWN_TABLE) /sizeof(msLoadTbl_S)); uctemp++)
3589 {
3590 W2BYTEMSK(tMHL_POWER_DOWN_TABLE[uctemp].addr, tMHL_POWER_DOWN_TABLE[uctemp].databuf, tMHL_POWER_DOWN_TABLE[uctemp].mask);
3591 }
3592
3593 for(uctemp = 0; uctemp < MHL_CBUS_SELECT_MASK; uctemp++)
3594 {
3595 _mhal_mhl_RxRtermControl(uctemp, RX_RTERM_OFF);
3596 }
3597 }
3598
3599 //**************************************************************************
3600 // [Function Name]:
3601 // mhal_mhl_SetHPD()
3602 // [Description]
3603 // config HPD in combo(MHL/HDMI) port A
3604 // [Arguments]:
3605 //
3606 // [Return]:
3607 //
3608 //**************************************************************************
mhal_mhl_SetHPD(MS_BOOL bflag)3609 void mhal_mhl_SetHPD(MS_BOOL bflag)
3610 {
3611 if(bflag) // HPD is high
3612 {
3613 W2BYTEMSK(REG_PM_MHL_CBUS_20, BIT(3), BMASK(4:3)); // [4]: output val, [3]: oen
3614 //msg_mhl(printf("**MHL_HPD is High"));
3615 }
3616 else // hpd is low
3617 {
3618 W2BYTEMSK(REG_PM_MHL_CBUS_20, 0, BMASK(4:3)); // [4]: output val, [3]: oen
3619 //msg_mhl(printf("**MHL_HPD is Low"));
3620 }
3621 }
3622
3623 //**************************************************************************
3624 // [Function Name]:
3625 // mhal_mhl_GetDDCErrorCode()
3626 // [Description]
3627 // Get DDC error code
3628 // [Arguments]:
3629 //
3630 // [Return]:
3631 //
3632 //**************************************************************************
mhal_mhl_GetDDCErrorCode(void)3633 MS_U8 mhal_mhl_GetDDCErrorCode(void)
3634 {
3635 return (R2BYTE(REG_MHL_CBUS_21)>>8);
3636 }
3637
3638 #if(MHL_CBUS_OPERATION_MODE == MHL_CBUS_HW_REPLY_MODE)
3639 //**************************************************************************
3640 // [Function Name]:
3641 // mhal_mhl_CheckSRAMReceiveBuffer()
3642 // [Description]
3643 //
3644 // [Arguments]:
3645 //
3646 // [Return]:
3647 //
3648 //**************************************************************************
mhal_mhl_CheckSRAMReceiveBuffer(void)3649 MS_BOOL mhal_mhl_CheckSRAMReceiveBuffer(void)
3650 {
3651 return ((R2BYTE(REG_MHL_CBUS_10) &BIT(4)) ?FALSE: TRUE);
3652 }
3653
3654 //**************************************************************************
3655 // [Function Name]:
3656 // mhal_mhl_GetSRAMReceiveData()
3657 // [Description]
3658 //
3659 // [Arguments]:
3660 //
3661 // [Return]:
3662 //
3663 //**************************************************************************
mhal_mhl_GetSRAMReceiveData(void)3664 MS_U16 mhal_mhl_GetSRAMReceiveData(void)
3665 {
3666 W2BYTEMSK(REG_MHL_CBUS_10, BIT(15), BIT(15));
3667
3668 while((R2BYTE(REG_MHL_CBUS_10) & BIT(14)) == BIT(14));
3669
3670 return R2BYTE(REG_MHL_CBUS_0F);
3671 }
3672
3673 #endif
3674
3675 #if(DMHL_TEST_SIGNAL_SUPPORT)
3676 //**************************************************************************
3677 // [Function Name]:
3678 // mhal_mhl_AdjustCommonModeResistor()
3679 // [Description]:
3680 //
3681 // [Arguments]:
3682 //
3683 // [Return]:
3684 //
3685 //**************************************************************************
mhal_mhl_TestSignal(MS_BOOL bflag)3686 void mhal_mhl_TestSignal(MS_BOOL bflag)
3687 {
3688 if(bflag)
3689 {
3690 W2BYTEMSK(0x001106, BIT(10), BIT(10));
3691 }
3692 else
3693 {
3694 W2BYTEMSK(0x001106, 0, BIT(10));
3695 }
3696 }
3697
3698 #endif
3699
3700 //**************************************************************************
3701 // [Function Name]:
3702 // mhal_mhl_SetMainLinkRate()
3703 // [Description]
3704 //
3705 // [Arguments]:
3706 //
3707 // [Return]:
3708 //
3709 //**************************************************************************
mhal_mhl_SetMainLinkRate(MS_U8 ucCbusSelect,MS_U8 ucLinkRate)3710 void mhal_mhl_SetMainLinkRate(MS_U8 ucCbusSelect, MS_U8 ucLinkRate)
3711 {
3712 MS_BOOL bLinkRate6GFlag = FALSE;
3713
3714 if(mhal_mhl_CheckInputPort(ucCbusSelect))
3715 {
3716 _mhal_mhl_Version3PhyEnable(ucCbusSelect, TRUE);
3717
3718 switch(ucCbusSelect)
3719 {
3720 #if(MHL_FUNCTION_SUPPORT_PORTA)
3721 case MHL_CBUS_SELECT_PORTA:
3722 if(GET_MHL_PATH_SUPPORT_PORTA())
3723 {
3724 if(ucLinkRate == MHL_AV_LINK_600)
3725 {
3726 bLinkRate6GFlag = TRUE;
3727 }
3728 else // MHL_AV_LINK_150 or MHL_AV_LINK_300
3729 {
3730
3731 }
3732 }
3733
3734 break;
3735 #endif
3736
3737 #if(MHL_FUNCTION_SUPPORT_PORTB)
3738 case MHL_CBUS_SELECT_PORTB:
3739 if(GET_MHL_PATH_SUPPORT_PORTB())
3740 {
3741 if(ucLinkRate == MHL_AV_LINK_600)
3742 {
3743 bLinkRate6GFlag = TRUE;
3744 }
3745 else // MHL_AV_LINK_150 or MHL_AV_LINK_300
3746 {
3747
3748 }
3749
3750 W2BYTEMSK(REG_COMBO_PHY1_P0_0D_L, (ucLinkRate << 12), BMASK(13:12)); // [13:12]: Select MHL3 data rate
3751 }
3752
3753 break;
3754 #endif
3755
3756 #if(MHL_FUNCTION_SUPPORT_PORTC)
3757 case MHL_CBUS_SELECT_PORTC:
3758 if(GET_MHL_PATH_SUPPORT_PORTC())
3759 {
3760 if(ucLinkRate == MHL_AV_LINK_600)
3761 {
3762 bLinkRate6GFlag = TRUE;
3763 }
3764 else // MHL_AV_LINK_150 or MHL_AV_LINK_300
3765 {
3766
3767 }
3768
3769 W2BYTEMSK(REG_COMBO_PHY1_P0_0D_L, (ucLinkRate << 12), BMASK(13:12)); // [13:12]: Select MHL3 data rate
3770 }
3771
3772 break;
3773 #endif
3774
3775 #if(MHL_FUNCTION_SUPPORT_PORTD)
3776 case MHL_CBUS_SELECT_PORTD:
3777 if(GET_MHL_PATH_SUPPORT_PORTD())
3778 {
3779 if(ucLinkRate == MHL_AV_LINK_600)
3780 {
3781 bLinkRate6GFlag = TRUE;
3782 }
3783 else // MHL_AV_LINK_150 or MHL_AV_LINK_300
3784 {
3785
3786 }
3787 }
3788
3789 break;
3790 #endif
3791
3792 default:
3793
3794 break;
3795 };
3796
3797 _mhal_mhl_MHL3MuxSetting0(bLinkRate6GFlag);
3798 }
3799
3800 ucMHL3LinkRate = ucLinkRate;
3801 }
3802
3803 //**************************************************************************
3804 // [Function Name]:
3805 // mhal_mhl_GetECbusStatusFlag()
3806 // [Description]:
3807 //
3808 // [Arguments]:
3809 //
3810 // [Return]:
3811 //
3812 //**************************************************************************
mhal_mhl_GetECbusStatusFlag(void)3813 MS_U8 mhal_mhl_GetECbusStatusFlag(void)
3814 {
3815 MS_U8 ucTrainState = (R2BYTE(REG_MHL_ECBUS_PHY_69) >> 12);
3816 MS_U8 ucECbusStatusFlag = 0;
3817
3818 if((ucECbusTrainState < MHL_ECBUS_STATE_FAIL) && (ucECbusTrainState >= MHL_ECBUS_STATE_SOURCE_ACTIVE))
3819 {
3820 ucECbusStatusFlag |= MHL_ECBUS_STATUS_TRAINING_PASS;
3821 }
3822
3823 if(R2BYTE(REG_MHL_ECBUS_PHY_6F) &BIT(13)) // [13]: ECbus clock lock flag
3824 {
3825 ucECbusStatusFlag |= MHL_ECBUS_STATUS_CLOCK_LOCK;
3826 }
3827
3828 if((ucTrainState >= MHL_ECBUS_TRAIN_WAIT_RRCEIVE_COMMA2) && (ucTrainState <= MHL_ECBUS_TRAIN_DONE))//Whan state of REG_PM_MHL_CBUS2_56 is equla 3, than state of REG_PM_MHL_CBUS2_69[51:12] will from 1 to 7.
3829 {
3830 //W2BYTEMSK(REG_MHL_ECBUS_PHY_56, 0x0200, BMASK(15:0)); // for auto train
3831 #if(MHL_ECBUS_AUTO_TRAINING)
3832 W2BYTEMSK(REG_MHL_ECBUS_PHY_4A, 0, BIT(13));
3833 #endif
3834 }
3835
3836 if(R2BYTE(REG_MHL_ECBUS_3A) &BIT(7)) // REG_MHL_CBUS2_3A[7]
3837 {
3838 ucECbusStatusFlag |= MHL_ECBUS_STATUS_SLOT_SYNC_DONE;
3839 }
3840
3841 if(R2BYTE(REG_MHL_ECBUS_3A) &BIT(15)) // REG_MHL_CBUS2_3A[15]
3842 {
3843 ucECbusStatusFlag |= MHL_ECBUS_STATUS_EMSC_SYNC_DONE;
3844 }
3845
3846 if(ucECbusTrainFailCount > 10)
3847 {
3848 ucECbusStatusFlag |= MHL_ECBUS_STATUS_RETRY_TIMEOUT;
3849
3850 ucECbusTrainFailCount = 0;
3851 }
3852
3853 return ucECbusStatusFlag;
3854 }
3855
3856 //**************************************************************************
3857 // [Function Name]:
3858 // mhal_mhl_ECbusEventProc()
3859 // [Description]
3860 //
3861 // [Arguments]:
3862 //
3863 // [Return]:
3864 //
3865 //**************************************************************************
mhal_mhl_ECbusEventProc(MS_U8 ucCbusSelect,MS_U8 ucECbusEvent)3866 void mhal_mhl_ECbusEventProc(MS_U8 ucCbusSelect, MS_U8 ucECbusEvent)
3867 {
3868 static MS_U8 ucECbusState = MHL_ECBUS_STATE_DISABLE;
3869
3870 if(ucECbusTrainState != ucECbusState)
3871 {
3872 MHAL_MHL_MSG_INFO("** MHL eCbus state %x\r\n", ucECbusTrainState);
3873
3874 ucECbusState = ucECbusTrainState;
3875 }
3876
3877 switch(ucECbusEvent)
3878 {
3879 case MHL_ECBUS_EVENT_PREPARE_MODE_UP:
3880 // Disable stuck to low interrupt
3881 mhal_mhl_CbusStucktoLow(FALSE);
3882 // Disable connect detect
3883 _mhal_mhl_CbusConnectCheckEnable(FALSE);
3884
3885 break;
3886
3887 case MHL_ECBUS_EVENT_MODE_UP_PROCESS:
3888 // Enable ECbus
3889 _mhal_mhl_ECbusEnableSetting(TRUE);
3890 // Set short read address to 0x70
3891 _mhal_mhl_SetShortReadAddress(TRUE);
3892 // Enable ECbus state change IRQ
3893 _mhal_mhl_SetECbusStateChangeInterrupt(TRUE);
3894 // Enable eMSC receive IRQ
3895 _mhal_mhl_SetEMSCReceiveInterrupt(TRUE);
3896
3897 _mhal_mhl_ECbusModeUpProc();
3898
3899 mhal_mhl_SetMainLinkRate(ucCbusSelect, MHL_AV_LINK_150);
3900
3901 ucECbusTrainFailCount = 0;
3902
3903 break;
3904
3905 case MHL_ECBUS_EVENT_PREPARE_MODE_DOWN:
3906
3907 break;
3908
3909 case MHL_ECBUS_EVENT_MODE_DOWN_PROCESS:
3910 case MHL_ECBUS_EVENT_STUCK_TO_LOW:
3911 // Enable connect detect
3912 _mhal_mhl_CbusConnectCheckEnable(TRUE);
3913 // Disable ECbus
3914 _mhal_mhl_ECbusEnableSetting(FALSE);
3915 // Clear short read address to 0x08
3916 _mhal_mhl_SetShortReadAddress(FALSE);
3917 // Disable ECbus state change IRQ
3918 _mhal_mhl_SetECbusStateChangeInterrupt(FALSE);
3919 // Disable eMSC receive IRQ
3920 _mhal_mhl_SetEMSCReceiveInterrupt(FALSE);
3921 // Disable MHL3 phy
3922 _mhal_mhl_Version3PhyEnable(ucCbusSelect, FALSE);
3923 // Reset all status
3924 W2BYTE(REG_MHL_ECBUS_34, 0xFFFF);
3925
3926 _mhal_mhl_CbusEngineReset();
3927
3928 break;
3929
3930 case MHL_ECBUS_EVENT_UNLOCK_RESET:
3931 //_mhal_mhl_ECbusDmuxEnable(FALSE);
3932 _mhal_mhl_ECbusStateReset();
3933
3934 ucECbusTrainFailCount = 0;
3935
3936 break;
3937
3938 #if(MHL_ECBUS_COMMAND_PARSING)
3939 case MHL_ECBUS_EVENT_ECBUS_COMMAND_PARSING:
3940 _mhal_mhl_GetECbusCommand();
3941
3942 break;
3943
3944 #endif
3945
3946 default:
3947
3948 break;
3949 };
3950 }
3951
3952 //**************************************************************************
3953 // [Function Name]:
3954 // mhal_mhl_GetEMSCReceiveData()
3955 // [Description]
3956 //
3957 // [Arguments]:
3958 //
3959 // [Return]:
3960 //
3961 //**************************************************************************
mhal_mhl_GetEMSCReceiveData(MS_U8 * bReveiceEMSC)3962 void mhal_mhl_GetEMSCReceiveData(MS_U8 *bReveiceEMSC)
3963 {
3964 MS_U8 uctemp = 0;
3965 MS_U16 usEMSCFreeBuffer = 0;
3966
3967 usEMSCFreeBuffer = (R2BYTE(REG_MHL_ECBUS_24) &BMASK(9:0)); // REG_MHL_ECBUS_24[9:0]
3968
3969 usEMSCFreeBuffer = MHL_EMSC_DATA_SIZE - usEMSCFreeBuffer;
3970
3971 bReveiceEMSC[0] = usEMSCFreeBuffer;
3972
3973 MHAL_MHL_MSG_INFO("** MHL eMSC length %d\r\n", usEMSCFreeBuffer);
3974
3975 for(uctemp = 0; uctemp < usEMSCFreeBuffer; uctemp++)
3976 {
3977 bReveiceEMSC[uctemp +1] = _mhal_mhl_GetSRAMReceiveEMSCData();
3978
3979 if(uctemp == 1) // Check length remaining
3980 {
3981 usEMSCFreeBuffer = bReveiceEMSC[uctemp +1] +2;
3982 }
3983
3984 MHAL_MHL_MSG_INFO("** MHL eMSC data %x\r\n", bReveiceEMSC[uctemp +1]);
3985 }
3986
3987 W2BYTEMSK(REG_MHL_ECBUS_1C, usEMSCFreeBuffer, BMASK(9:0));
3988 W2BYTEMSK(REG_MHL_ECBUS_1C, BIT(15), BIT(15));
3989 }
3990
3991 //**************************************************************************
3992 // [Function Name]:
3993 // mhal_mhl_InsertEMSCSendData()
3994 // [Description]
3995 //
3996 // [Arguments]:
3997 //
3998 // [Return]:
3999 //
4000 //**************************************************************************
mhal_mhl_InsertEMSCSendData(MS_U8 ucLength,MS_U8 * bSendEMSC)4001 void mhal_mhl_InsertEMSCSendData(MS_U8 ucLength, MS_U8 *bSendEMSC)
4002 {
4003 MS_U8 uctemp = 0;
4004 MS_U16 usPayloadCRC = 0xFFFF;
4005
4006 if((ucLength > 0) && (bSendEMSC != NULL))
4007 {
4008 W2BYTEMSK(REG_MHL_ECBUS_1B, (ucLength -1), BMASK(9:0)); // Request command byte count
4009 W2BYTEMSK(REG_MHL_ECBUS_79, _mhal_mhl_GetEMSCTwoByteCRC(0, (ucLength -1)) , BMASK(2:0)); // byte count CRC
4010
4011 W2BYTEMSK(REG_MHL_ECBUS_21, 0, BMASK(9:0)); // SRAM address set 0
4012 W2BYTEMSK(REG_MHL_ECBUS_21, BIT(13), BIT(13)); // Trigger address
4013
4014 for(uctemp = 0; uctemp < ucLength; uctemp++)
4015 {
4016 _mhal_mhl_InsertSRAMSendEMSCData(bSendEMSC[uctemp]);
4017
4018 MHAL_MHL_MSG_INFO("** MHL payload value %x\r\n", bSendEMSC[uctemp]);
4019
4020 usPayloadCRC = _mhal_mhl_GetEMSCPayloadCRC(bSendEMSC[uctemp], usPayloadCRC);
4021 }
4022
4023 W2BYTEMSK(REG_MHL_ECBUS_19, BIT(15), BIT(15)); // eMSC payload CRC ove
4024 W2BYTE(REG_MHL_ECBUS_1A, (usPayloadCRC ^0xFFFF)); // eMSC payload CRC value
4025
4026 MHAL_MHL_MSG_INFO("** MHL payload CRC value %x\r\n", (usPayloadCRC ^0xFFFF));
4027
4028 W2BYTEMSK(REG_MHL_ECBUS_1B, BIT(15), BIT(15)); // REG_MHL_ECBUS2_1B[15]
4029 }
4030 }
4031
4032 #endif // _MHAL_MHL_C_
4033
4034