1 // SPDX-License-Identifier: GPL-2.0-only
3 * Copyright (c) 2014 MediaTek Inc.
4 * Author: Jie Qiu <jie.qiu@mediatek.com>
7 #include <linux/arm-smccc.h>
9 #include <linux/delay.h>
10 #include <linux/hdmi.h>
11 #include <linux/i2c.h>
13 #include <linux/kernel.h>
14 #include <linux/mfd/syscon.h>
15 #include <linux/mutex.h>
16 #include <linux/of_platform.h>
18 #include <linux/of_gpio.h>
19 #include <linux/of_graph.h>
20 #include <linux/phy/phy.h>
21 #include <linux/platform_device.h>
22 #include <linux/regmap.h>
24 #include <sound/hdmi-codec.h>
26 #include <drm/drm_atomic_helper.h>
27 #include <drm/drm_bridge.h>
28 #include <drm/drm_crtc.h>
29 #include <drm/drm_edid.h>
30 #include <drm/drm_print.h>
31 #include <drm/drm_probe_helper.h>
35 #include "mtk_hdmi_regs.h"
39 enum mtk_hdmi_clk_id
{
40 MTK_HDMI_CLK_HDMI_PIXEL
,
41 MTK_HDMI_CLK_HDMI_PLL
,
42 MTK_HDMI_CLK_AUD_BCLK
,
43 MTK_HDMI_CLK_AUD_SPDIF
,
47 enum hdmi_aud_input_type
{
48 HDMI_AUD_INPUT_I2S
= 0,
52 enum hdmi_aud_i2s_fmt
{
53 HDMI_I2S_MODE_RJT_24BIT
= 0,
54 HDMI_I2S_MODE_RJT_16BIT
,
55 HDMI_I2S_MODE_LJT_24BIT
,
56 HDMI_I2S_MODE_LJT_16BIT
,
57 HDMI_I2S_MODE_I2S_24BIT
,
58 HDMI_I2S_MODE_I2S_16BIT
71 enum hdmi_aud_channel_type
{
72 HDMI_AUD_CHAN_TYPE_1_0
= 0,
73 HDMI_AUD_CHAN_TYPE_1_1
,
74 HDMI_AUD_CHAN_TYPE_2_0
,
75 HDMI_AUD_CHAN_TYPE_2_1
,
76 HDMI_AUD_CHAN_TYPE_3_0
,
77 HDMI_AUD_CHAN_TYPE_3_1
,
78 HDMI_AUD_CHAN_TYPE_4_0
,
79 HDMI_AUD_CHAN_TYPE_4_1
,
80 HDMI_AUD_CHAN_TYPE_5_0
,
81 HDMI_AUD_CHAN_TYPE_5_1
,
82 HDMI_AUD_CHAN_TYPE_6_0
,
83 HDMI_AUD_CHAN_TYPE_6_1
,
84 HDMI_AUD_CHAN_TYPE_7_0
,
85 HDMI_AUD_CHAN_TYPE_7_1
,
86 HDMI_AUD_CHAN_TYPE_3_0_LRS
,
87 HDMI_AUD_CHAN_TYPE_3_1_LRS
,
88 HDMI_AUD_CHAN_TYPE_4_0_CLRS
,
89 HDMI_AUD_CHAN_TYPE_4_1_CLRS
,
90 HDMI_AUD_CHAN_TYPE_6_1_CS
,
91 HDMI_AUD_CHAN_TYPE_6_1_CH
,
92 HDMI_AUD_CHAN_TYPE_6_1_OH
,
93 HDMI_AUD_CHAN_TYPE_6_1_CHR
,
94 HDMI_AUD_CHAN_TYPE_7_1_LH_RH
,
95 HDMI_AUD_CHAN_TYPE_7_1_LSR_RSR
,
96 HDMI_AUD_CHAN_TYPE_7_1_LC_RC
,
97 HDMI_AUD_CHAN_TYPE_7_1_LW_RW
,
98 HDMI_AUD_CHAN_TYPE_7_1_LSD_RSD
,
99 HDMI_AUD_CHAN_TYPE_7_1_LSS_RSS
,
100 HDMI_AUD_CHAN_TYPE_7_1_LHS_RHS
,
101 HDMI_AUD_CHAN_TYPE_7_1_CS_CH
,
102 HDMI_AUD_CHAN_TYPE_7_1_CS_OH
,
103 HDMI_AUD_CHAN_TYPE_7_1_CS_CHR
,
104 HDMI_AUD_CHAN_TYPE_7_1_CH_OH
,
105 HDMI_AUD_CHAN_TYPE_7_1_CH_CHR
,
106 HDMI_AUD_CHAN_TYPE_7_1_OH_CHR
,
107 HDMI_AUD_CHAN_TYPE_7_1_LSS_RSS_LSR_RSR
,
108 HDMI_AUD_CHAN_TYPE_6_0_CS
,
109 HDMI_AUD_CHAN_TYPE_6_0_CH
,
110 HDMI_AUD_CHAN_TYPE_6_0_OH
,
111 HDMI_AUD_CHAN_TYPE_6_0_CHR
,
112 HDMI_AUD_CHAN_TYPE_7_0_LH_RH
,
113 HDMI_AUD_CHAN_TYPE_7_0_LSR_RSR
,
114 HDMI_AUD_CHAN_TYPE_7_0_LC_RC
,
115 HDMI_AUD_CHAN_TYPE_7_0_LW_RW
,
116 HDMI_AUD_CHAN_TYPE_7_0_LSD_RSD
,
117 HDMI_AUD_CHAN_TYPE_7_0_LSS_RSS
,
118 HDMI_AUD_CHAN_TYPE_7_0_LHS_RHS
,
119 HDMI_AUD_CHAN_TYPE_7_0_CS_CH
,
120 HDMI_AUD_CHAN_TYPE_7_0_CS_OH
,
121 HDMI_AUD_CHAN_TYPE_7_0_CS_CHR
,
122 HDMI_AUD_CHAN_TYPE_7_0_CH_OH
,
123 HDMI_AUD_CHAN_TYPE_7_0_CH_CHR
,
124 HDMI_AUD_CHAN_TYPE_7_0_OH_CHR
,
125 HDMI_AUD_CHAN_TYPE_7_0_LSS_RSS_LSR_RSR
,
126 HDMI_AUD_CHAN_TYPE_8_0_LH_RH_CS
,
127 HDMI_AUD_CHAN_TYPE_UNKNOWN
= 0xFF
130 enum hdmi_aud_channel_swap_type
{
132 HDMI_AUD_SWAP_LFE_CC
,
134 HDMI_AUD_SWAP_RLS_RRS
,
135 HDMI_AUD_SWAP_LR_STATUS
,
138 struct hdmi_audio_param
{
139 enum hdmi_audio_coding_type aud_codec
;
140 enum hdmi_audio_sample_size aud_sampe_size
;
141 enum hdmi_aud_input_type aud_input_type
;
142 enum hdmi_aud_i2s_fmt aud_i2s_fmt
;
143 enum hdmi_aud_mclk aud_mclk
;
144 enum hdmi_aud_channel_type aud_input_chan_type
;
145 struct hdmi_codec_params codec_params
;
149 struct drm_bridge bridge
;
150 struct drm_bridge
*next_bridge
;
151 struct drm_connector conn
;
154 struct device
*cec_dev
;
155 struct i2c_adapter
*ddc_adpt
;
156 struct clk
*clk
[MTK_HDMI_CLK_COUNT
];
157 struct drm_display_mode mode
;
165 struct regmap
*sys_regmap
;
166 unsigned int sys_offset
;
168 enum hdmi_colorspace csp
;
169 struct hdmi_audio_param aud_param
;
173 hdmi_codec_plugged_cb plugged_cb
;
174 struct device
*codec_dev
;
175 struct mutex update_plugged_status_lock
;
178 static inline struct mtk_hdmi
*hdmi_ctx_from_bridge(struct drm_bridge
*b
)
180 return container_of(b
, struct mtk_hdmi
, bridge
);
183 static inline struct mtk_hdmi
*hdmi_ctx_from_conn(struct drm_connector
*c
)
185 return container_of(c
, struct mtk_hdmi
, conn
);
188 static u32
mtk_hdmi_read(struct mtk_hdmi
*hdmi
, u32 offset
)
190 return readl(hdmi
->regs
+ offset
);
193 static void mtk_hdmi_write(struct mtk_hdmi
*hdmi
, u32 offset
, u32 val
)
195 writel(val
, hdmi
->regs
+ offset
);
198 static void mtk_hdmi_clear_bits(struct mtk_hdmi
*hdmi
, u32 offset
, u32 bits
)
200 void __iomem
*reg
= hdmi
->regs
+ offset
;
208 static void mtk_hdmi_set_bits(struct mtk_hdmi
*hdmi
, u32 offset
, u32 bits
)
210 void __iomem
*reg
= hdmi
->regs
+ offset
;
218 static void mtk_hdmi_mask(struct mtk_hdmi
*hdmi
, u32 offset
, u32 val
, u32 mask
)
220 void __iomem
*reg
= hdmi
->regs
+ offset
;
224 tmp
= (tmp
& ~mask
) | (val
& mask
);
228 static void mtk_hdmi_hw_vid_black(struct mtk_hdmi
*hdmi
, bool black
)
230 mtk_hdmi_mask(hdmi
, VIDEO_CFG_4
, black
? GEN_RGB
: NORMAL_PATH
,
234 static void mtk_hdmi_hw_make_reg_writable(struct mtk_hdmi
*hdmi
, bool enable
)
236 struct arm_smccc_res res
;
237 struct mtk_hdmi_phy
*hdmi_phy
= phy_get_drvdata(hdmi
->phy
);
240 * MT8173 HDMI hardware has an output control bit to enable/disable HDMI
241 * output. This bit can only be controlled in ARM supervisor mode.
242 * The ARM trusted firmware provides an API for the HDMI driver to set
243 * this control bit to enable HDMI output in supervisor mode.
245 if (hdmi_phy
->conf
&& hdmi_phy
->conf
->tz_disabled
)
246 regmap_update_bits(hdmi
->sys_regmap
,
247 hdmi
->sys_offset
+ HDMI_SYS_CFG20
,
248 0x80008005, enable
? 0x80000005 : 0x8000);
250 arm_smccc_smc(MTK_SIP_SET_AUTHORIZED_SECURE_REG
, 0x14000904,
251 0x80000000, 0, 0, 0, 0, 0, &res
);
253 regmap_update_bits(hdmi
->sys_regmap
, hdmi
->sys_offset
+ HDMI_SYS_CFG20
,
254 HDMI_PCLK_FREE_RUN
, enable
? HDMI_PCLK_FREE_RUN
: 0);
255 regmap_update_bits(hdmi
->sys_regmap
, hdmi
->sys_offset
+ HDMI_SYS_CFG1C
,
256 HDMI_ON
| ANLG_ON
, enable
? (HDMI_ON
| ANLG_ON
) : 0);
259 static void mtk_hdmi_hw_1p4_version_enable(struct mtk_hdmi
*hdmi
, bool enable
)
261 regmap_update_bits(hdmi
->sys_regmap
, hdmi
->sys_offset
+ HDMI_SYS_CFG20
,
262 HDMI2P0_EN
, enable
? 0 : HDMI2P0_EN
);
265 static void mtk_hdmi_hw_aud_mute(struct mtk_hdmi
*hdmi
)
267 mtk_hdmi_set_bits(hdmi
, GRL_AUDIO_CFG
, AUDIO_ZERO
);
270 static void mtk_hdmi_hw_aud_unmute(struct mtk_hdmi
*hdmi
)
272 mtk_hdmi_clear_bits(hdmi
, GRL_AUDIO_CFG
, AUDIO_ZERO
);
275 static void mtk_hdmi_hw_reset(struct mtk_hdmi
*hdmi
)
277 regmap_update_bits(hdmi
->sys_regmap
, hdmi
->sys_offset
+ HDMI_SYS_CFG1C
,
279 regmap_update_bits(hdmi
->sys_regmap
, hdmi
->sys_offset
+ HDMI_SYS_CFG1C
,
281 mtk_hdmi_clear_bits(hdmi
, GRL_CFG3
, CFG3_CONTROL_PACKET_DELAY
);
282 regmap_update_bits(hdmi
->sys_regmap
, hdmi
->sys_offset
+ HDMI_SYS_CFG1C
,
286 static void mtk_hdmi_hw_enable_notice(struct mtk_hdmi
*hdmi
, bool enable_notice
)
288 mtk_hdmi_mask(hdmi
, GRL_CFG2
, enable_notice
? CFG2_NOTICE_EN
: 0,
292 static void mtk_hdmi_hw_write_int_mask(struct mtk_hdmi
*hdmi
, u32 int_mask
)
294 mtk_hdmi_write(hdmi
, GRL_INT_MASK
, int_mask
);
297 static void mtk_hdmi_hw_enable_dvi_mode(struct mtk_hdmi
*hdmi
, bool enable
)
299 mtk_hdmi_mask(hdmi
, GRL_CFG1
, enable
? CFG1_DVI
: 0, CFG1_DVI
);
302 static void mtk_hdmi_hw_send_info_frame(struct mtk_hdmi
*hdmi
, u8
*buffer
,
305 u32 ctrl_reg
= GRL_CTRL
;
308 enum hdmi_infoframe_type frame_type
;
312 int ctrl_frame_en
= 0;
314 frame_type
= *buffer
++;
315 frame_ver
= *buffer
++;
316 frame_len
= *buffer
++;
317 checksum
= *buffer
++;
321 "frame_type:0x%x,frame_ver:0x%x,frame_len:0x%x,checksum:0x%x\n",
322 frame_type
, frame_ver
, frame_len
, checksum
);
324 switch (frame_type
) {
325 case HDMI_INFOFRAME_TYPE_AVI
:
326 ctrl_frame_en
= CTRL_AVI_EN
;
329 case HDMI_INFOFRAME_TYPE_SPD
:
330 ctrl_frame_en
= CTRL_SPD_EN
;
333 case HDMI_INFOFRAME_TYPE_AUDIO
:
334 ctrl_frame_en
= CTRL_AUDIO_EN
;
337 case HDMI_INFOFRAME_TYPE_VENDOR
:
338 ctrl_frame_en
= VS_EN
;
339 ctrl_reg
= GRL_ACP_ISRC_CTRL
;
342 dev_err(hdmi
->dev
, "Unknown infoframe type %d\n", frame_type
);
345 mtk_hdmi_clear_bits(hdmi
, ctrl_reg
, ctrl_frame_en
);
346 mtk_hdmi_write(hdmi
, GRL_INFOFRM_TYPE
, frame_type
);
347 mtk_hdmi_write(hdmi
, GRL_INFOFRM_VER
, frame_ver
);
348 mtk_hdmi_write(hdmi
, GRL_INFOFRM_LNG
, frame_len
);
350 mtk_hdmi_write(hdmi
, GRL_IFM_PORT
, checksum
);
351 for (i
= 0; i
< frame_len
; i
++)
352 mtk_hdmi_write(hdmi
, GRL_IFM_PORT
, frame_data
[i
]);
354 mtk_hdmi_set_bits(hdmi
, ctrl_reg
, ctrl_frame_en
);
357 static void mtk_hdmi_hw_send_aud_packet(struct mtk_hdmi
*hdmi
, bool enable
)
359 mtk_hdmi_mask(hdmi
, GRL_SHIFT_R2
, enable
? 0 : AUDIO_PACKET_OFF
,
363 static void mtk_hdmi_hw_config_sys(struct mtk_hdmi
*hdmi
)
365 regmap_update_bits(hdmi
->sys_regmap
, hdmi
->sys_offset
+ HDMI_SYS_CFG20
,
366 HDMI_OUT_FIFO_EN
| MHL_MODE_ON
, 0);
367 usleep_range(2000, 4000);
368 regmap_update_bits(hdmi
->sys_regmap
, hdmi
->sys_offset
+ HDMI_SYS_CFG20
,
369 HDMI_OUT_FIFO_EN
| MHL_MODE_ON
, HDMI_OUT_FIFO_EN
);
372 static void mtk_hdmi_hw_set_deep_color_mode(struct mtk_hdmi
*hdmi
)
374 regmap_update_bits(hdmi
->sys_regmap
, hdmi
->sys_offset
+ HDMI_SYS_CFG20
,
375 DEEP_COLOR_MODE_MASK
| DEEP_COLOR_EN
,
379 static void mtk_hdmi_hw_send_av_mute(struct mtk_hdmi
*hdmi
)
381 mtk_hdmi_clear_bits(hdmi
, GRL_CFG4
, CTRL_AVMUTE
);
382 usleep_range(2000, 4000);
383 mtk_hdmi_set_bits(hdmi
, GRL_CFG4
, CTRL_AVMUTE
);
386 static void mtk_hdmi_hw_send_av_unmute(struct mtk_hdmi
*hdmi
)
388 mtk_hdmi_mask(hdmi
, GRL_CFG4
, CFG4_AV_UNMUTE_EN
,
389 CFG4_AV_UNMUTE_EN
| CFG4_AV_UNMUTE_SET
);
390 usleep_range(2000, 4000);
391 mtk_hdmi_mask(hdmi
, GRL_CFG4
, CFG4_AV_UNMUTE_SET
,
392 CFG4_AV_UNMUTE_EN
| CFG4_AV_UNMUTE_SET
);
395 static void mtk_hdmi_hw_ncts_enable(struct mtk_hdmi
*hdmi
, bool on
)
397 mtk_hdmi_mask(hdmi
, GRL_CTS_CTRL
, on
? 0 : CTS_CTRL_SOFT
,
401 static void mtk_hdmi_hw_ncts_auto_write_enable(struct mtk_hdmi
*hdmi
,
404 mtk_hdmi_mask(hdmi
, GRL_CTS_CTRL
, enable
? NCTS_WRI_ANYTIME
: 0,
408 static void mtk_hdmi_hw_msic_setting(struct mtk_hdmi
*hdmi
,
409 struct drm_display_mode
*mode
)
411 mtk_hdmi_clear_bits(hdmi
, GRL_CFG4
, CFG4_MHL_MODE
);
413 if (mode
->flags
& DRM_MODE_FLAG_INTERLACE
&&
414 mode
->clock
== 74250 &&
415 mode
->vdisplay
== 1080)
416 mtk_hdmi_clear_bits(hdmi
, GRL_CFG2
, CFG2_MHL_DE_SEL
);
418 mtk_hdmi_set_bits(hdmi
, GRL_CFG2
, CFG2_MHL_DE_SEL
);
421 static void mtk_hdmi_hw_aud_set_channel_swap(struct mtk_hdmi
*hdmi
,
422 enum hdmi_aud_channel_swap_type swap
)
427 case HDMI_AUD_SWAP_LR
:
430 case HDMI_AUD_SWAP_LFE_CC
:
431 swap_bit
= LFE_CC_SWAP
;
433 case HDMI_AUD_SWAP_LSRS
:
434 swap_bit
= LSRS_SWAP
;
436 case HDMI_AUD_SWAP_RLS_RRS
:
437 swap_bit
= RLS_RRS_SWAP
;
439 case HDMI_AUD_SWAP_LR_STATUS
:
440 swap_bit
= LR_STATUS_SWAP
;
443 swap_bit
= LFE_CC_SWAP
;
446 mtk_hdmi_mask(hdmi
, GRL_CH_SWAP
, swap_bit
, 0xff);
449 static void mtk_hdmi_hw_aud_set_bit_num(struct mtk_hdmi
*hdmi
,
450 enum hdmi_audio_sample_size bit_num
)
455 case HDMI_AUDIO_SAMPLE_SIZE_16
:
458 case HDMI_AUDIO_SAMPLE_SIZE_20
:
461 case HDMI_AUDIO_SAMPLE_SIZE_24
:
462 case HDMI_AUDIO_SAMPLE_SIZE_STREAM
:
467 mtk_hdmi_mask(hdmi
, GRL_AOUT_CFG
, val
, AOUT_BNUM_SEL_MASK
);
470 static void mtk_hdmi_hw_aud_set_i2s_fmt(struct mtk_hdmi
*hdmi
,
471 enum hdmi_aud_i2s_fmt i2s_fmt
)
475 val
= mtk_hdmi_read(hdmi
, GRL_CFG0
);
476 val
&= ~(CFG0_W_LENGTH_MASK
| CFG0_I2S_MODE_MASK
);
479 case HDMI_I2S_MODE_RJT_24BIT
:
480 val
|= CFG0_I2S_MODE_RTJ
| CFG0_W_LENGTH_24BIT
;
482 case HDMI_I2S_MODE_RJT_16BIT
:
483 val
|= CFG0_I2S_MODE_RTJ
| CFG0_W_LENGTH_16BIT
;
485 case HDMI_I2S_MODE_LJT_24BIT
:
487 val
|= CFG0_I2S_MODE_LTJ
| CFG0_W_LENGTH_24BIT
;
489 case HDMI_I2S_MODE_LJT_16BIT
:
490 val
|= CFG0_I2S_MODE_LTJ
| CFG0_W_LENGTH_16BIT
;
492 case HDMI_I2S_MODE_I2S_24BIT
:
493 val
|= CFG0_I2S_MODE_I2S
| CFG0_W_LENGTH_24BIT
;
495 case HDMI_I2S_MODE_I2S_16BIT
:
496 val
|= CFG0_I2S_MODE_I2S
| CFG0_W_LENGTH_16BIT
;
499 mtk_hdmi_write(hdmi
, GRL_CFG0
, val
);
502 static void mtk_hdmi_hw_audio_config(struct mtk_hdmi
*hdmi
, bool dst
)
504 const u8 mask
= HIGH_BIT_RATE
| DST_NORMAL_DOUBLE
| SACD_DST
| DSD_SEL
;
507 /* Disable high bitrate, set DST packet normal/double */
508 mtk_hdmi_clear_bits(hdmi
, GRL_AOUT_CFG
, HIGH_BIT_RATE_PACKET_ALIGN
);
511 val
= DST_NORMAL_DOUBLE
| SACD_DST
;
515 mtk_hdmi_mask(hdmi
, GRL_AUDIO_CFG
, val
, mask
);
518 static void mtk_hdmi_hw_aud_set_i2s_chan_num(struct mtk_hdmi
*hdmi
,
519 enum hdmi_aud_channel_type channel_type
,
522 unsigned int ch_switch
;
525 ch_switch
= CH_SWITCH(7, 7) | CH_SWITCH(6, 6) |
526 CH_SWITCH(5, 5) | CH_SWITCH(4, 4) |
527 CH_SWITCH(3, 3) | CH_SWITCH(1, 2) |
528 CH_SWITCH(2, 1) | CH_SWITCH(0, 0);
530 if (channel_count
== 2) {
531 i2s_uv
= I2S_UV_CH_EN(0);
532 } else if (channel_count
== 3 || channel_count
== 4) {
533 if (channel_count
== 4 &&
534 (channel_type
== HDMI_AUD_CHAN_TYPE_3_0_LRS
||
535 channel_type
== HDMI_AUD_CHAN_TYPE_4_0
))
536 i2s_uv
= I2S_UV_CH_EN(2) | I2S_UV_CH_EN(0);
538 i2s_uv
= I2S_UV_CH_EN(3) | I2S_UV_CH_EN(2);
539 } else if (channel_count
== 6 || channel_count
== 5) {
540 if (channel_count
== 6 &&
541 channel_type
!= HDMI_AUD_CHAN_TYPE_5_1
&&
542 channel_type
!= HDMI_AUD_CHAN_TYPE_4_1_CLRS
) {
543 i2s_uv
= I2S_UV_CH_EN(3) | I2S_UV_CH_EN(2) |
544 I2S_UV_CH_EN(1) | I2S_UV_CH_EN(0);
546 i2s_uv
= I2S_UV_CH_EN(2) | I2S_UV_CH_EN(1) |
549 } else if (channel_count
== 8 || channel_count
== 7) {
550 i2s_uv
= I2S_UV_CH_EN(3) | I2S_UV_CH_EN(2) |
551 I2S_UV_CH_EN(1) | I2S_UV_CH_EN(0);
553 i2s_uv
= I2S_UV_CH_EN(0);
556 mtk_hdmi_write(hdmi
, GRL_CH_SW0
, ch_switch
& 0xff);
557 mtk_hdmi_write(hdmi
, GRL_CH_SW1
, (ch_switch
>> 8) & 0xff);
558 mtk_hdmi_write(hdmi
, GRL_CH_SW2
, (ch_switch
>> 16) & 0xff);
559 mtk_hdmi_write(hdmi
, GRL_I2S_UV
, i2s_uv
);
562 static void mtk_hdmi_hw_aud_set_input_type(struct mtk_hdmi
*hdmi
,
563 enum hdmi_aud_input_type input_type
)
567 val
= mtk_hdmi_read(hdmi
, GRL_CFG1
);
568 if (input_type
== HDMI_AUD_INPUT_I2S
&&
569 (val
& CFG1_SPDIF
) == CFG1_SPDIF
) {
571 } else if (input_type
== HDMI_AUD_INPUT_SPDIF
&&
572 (val
& CFG1_SPDIF
) == 0) {
575 mtk_hdmi_write(hdmi
, GRL_CFG1
, val
);
578 static void mtk_hdmi_hw_aud_set_channel_status(struct mtk_hdmi
*hdmi
,
583 for (i
= 0; i
< 5; i
++) {
584 mtk_hdmi_write(hdmi
, GRL_I2S_C_STA0
+ i
* 4, channel_status
[i
]);
585 mtk_hdmi_write(hdmi
, GRL_L_STATUS_0
+ i
* 4, channel_status
[i
]);
586 mtk_hdmi_write(hdmi
, GRL_R_STATUS_0
+ i
* 4, channel_status
[i
]);
588 for (; i
< 24; i
++) {
589 mtk_hdmi_write(hdmi
, GRL_L_STATUS_0
+ i
* 4, 0);
590 mtk_hdmi_write(hdmi
, GRL_R_STATUS_0
+ i
* 4, 0);
594 static void mtk_hdmi_hw_aud_src_reenable(struct mtk_hdmi
*hdmi
)
598 val
= mtk_hdmi_read(hdmi
, GRL_MIX_CTRL
);
599 if (val
& MIX_CTRL_SRC_EN
) {
600 val
&= ~MIX_CTRL_SRC_EN
;
601 mtk_hdmi_write(hdmi
, GRL_MIX_CTRL
, val
);
602 usleep_range(255, 512);
603 val
|= MIX_CTRL_SRC_EN
;
604 mtk_hdmi_write(hdmi
, GRL_MIX_CTRL
, val
);
608 static void mtk_hdmi_hw_aud_src_disable(struct mtk_hdmi
*hdmi
)
612 val
= mtk_hdmi_read(hdmi
, GRL_MIX_CTRL
);
613 val
&= ~MIX_CTRL_SRC_EN
;
614 mtk_hdmi_write(hdmi
, GRL_MIX_CTRL
, val
);
615 mtk_hdmi_write(hdmi
, GRL_SHIFT_L1
, 0x00);
618 static void mtk_hdmi_hw_aud_set_mclk(struct mtk_hdmi
*hdmi
,
619 enum hdmi_aud_mclk mclk
)
623 val
= mtk_hdmi_read(hdmi
, GRL_CFG5
);
624 val
&= CFG5_CD_RATIO_MASK
;
627 case HDMI_AUD_MCLK_128FS
:
630 case HDMI_AUD_MCLK_256FS
:
633 case HDMI_AUD_MCLK_384FS
:
636 case HDMI_AUD_MCLK_512FS
:
639 case HDMI_AUD_MCLK_768FS
:
646 mtk_hdmi_write(hdmi
, GRL_CFG5
, val
);
654 /* Recommended N values from HDMI specification, tables 7-1 to 7-3 */
655 static const struct hdmi_acr_n hdmi_rec_n_table
[] = {
656 /* Clock, N: 32kHz 44.1kHz 48kHz */
657 { 25175, { 4576, 7007, 6864 } },
658 { 74176, { 11648, 17836, 11648 } },
659 { 148352, { 11648, 8918, 5824 } },
660 { 296703, { 5824, 4459, 5824 } },
661 { 297000, { 3072, 4704, 5120 } },
662 { 0, { 4096, 6272, 6144 } }, /* all other TMDS clocks */
666 * hdmi_recommended_n() - Return N value recommended by HDMI specification
667 * @freq: audio sample rate in Hz
668 * @clock: rounded TMDS clock in kHz
670 static unsigned int hdmi_recommended_n(unsigned int freq
, unsigned int clock
)
672 const struct hdmi_acr_n
*recommended
;
675 for (i
= 0; i
< ARRAY_SIZE(hdmi_rec_n_table
) - 1; i
++) {
676 if (clock
== hdmi_rec_n_table
[i
].clock
)
679 recommended
= hdmi_rec_n_table
+ i
;
683 return recommended
->n
[0];
685 return recommended
->n
[1];
687 return recommended
->n
[2];
689 return recommended
->n
[1] * 2;
691 return recommended
->n
[2] * 2;
693 return recommended
->n
[1] * 4;
695 return recommended
->n
[2] * 4;
697 return (128 * freq
) / 1000;
701 static unsigned int hdmi_mode_clock_to_hz(unsigned int clock
)
705 return 25174825; /* 25.2/1.001 MHz */
707 return 74175824; /* 74.25/1.001 MHz */
709 return 148351648; /* 148.5/1.001 MHz */
711 return 296703297; /* 297/1.001 MHz */
717 static unsigned int hdmi_expected_cts(unsigned int audio_sample_rate
,
718 unsigned int tmds_clock
, unsigned int n
)
720 return DIV_ROUND_CLOSEST_ULL((u64
)hdmi_mode_clock_to_hz(tmds_clock
) * n
,
721 128 * audio_sample_rate
);
724 static void do_hdmi_hw_aud_set_ncts(struct mtk_hdmi
*hdmi
, unsigned int n
,
727 unsigned char val
[NCTS_BYTES
];
730 mtk_hdmi_write(hdmi
, GRL_NCTS
, 0);
731 mtk_hdmi_write(hdmi
, GRL_NCTS
, 0);
732 mtk_hdmi_write(hdmi
, GRL_NCTS
, 0);
733 memset(val
, 0, sizeof(val
));
735 val
[0] = (cts
>> 24) & 0xff;
736 val
[1] = (cts
>> 16) & 0xff;
737 val
[2] = (cts
>> 8) & 0xff;
740 val
[4] = (n
>> 16) & 0xff;
741 val
[5] = (n
>> 8) & 0xff;
744 for (i
= 0; i
< NCTS_BYTES
; i
++)
745 mtk_hdmi_write(hdmi
, GRL_NCTS
, val
[i
]);
748 static void mtk_hdmi_hw_aud_set_ncts(struct mtk_hdmi
*hdmi
,
749 unsigned int sample_rate
,
754 n
= hdmi_recommended_n(sample_rate
, clock
);
755 cts
= hdmi_expected_cts(sample_rate
, clock
, n
);
757 dev_dbg(hdmi
->dev
, "%s: sample_rate=%u, clock=%d, cts=%u, n=%u\n",
758 __func__
, sample_rate
, clock
, n
, cts
);
760 mtk_hdmi_mask(hdmi
, DUMMY_304
, AUDIO_I2S_NCTS_SEL_64
,
762 do_hdmi_hw_aud_set_ncts(hdmi
, n
, cts
);
765 static u8
mtk_hdmi_aud_get_chnl_count(enum hdmi_aud_channel_type channel_type
)
767 switch (channel_type
) {
768 case HDMI_AUD_CHAN_TYPE_1_0
:
769 case HDMI_AUD_CHAN_TYPE_1_1
:
770 case HDMI_AUD_CHAN_TYPE_2_0
:
772 case HDMI_AUD_CHAN_TYPE_2_1
:
773 case HDMI_AUD_CHAN_TYPE_3_0
:
775 case HDMI_AUD_CHAN_TYPE_3_1
:
776 case HDMI_AUD_CHAN_TYPE_4_0
:
777 case HDMI_AUD_CHAN_TYPE_3_0_LRS
:
779 case HDMI_AUD_CHAN_TYPE_4_1
:
780 case HDMI_AUD_CHAN_TYPE_5_0
:
781 case HDMI_AUD_CHAN_TYPE_3_1_LRS
:
782 case HDMI_AUD_CHAN_TYPE_4_0_CLRS
:
784 case HDMI_AUD_CHAN_TYPE_5_1
:
785 case HDMI_AUD_CHAN_TYPE_6_0
:
786 case HDMI_AUD_CHAN_TYPE_4_1_CLRS
:
787 case HDMI_AUD_CHAN_TYPE_6_0_CS
:
788 case HDMI_AUD_CHAN_TYPE_6_0_CH
:
789 case HDMI_AUD_CHAN_TYPE_6_0_OH
:
790 case HDMI_AUD_CHAN_TYPE_6_0_CHR
:
792 case HDMI_AUD_CHAN_TYPE_6_1
:
793 case HDMI_AUD_CHAN_TYPE_6_1_CS
:
794 case HDMI_AUD_CHAN_TYPE_6_1_CH
:
795 case HDMI_AUD_CHAN_TYPE_6_1_OH
:
796 case HDMI_AUD_CHAN_TYPE_6_1_CHR
:
797 case HDMI_AUD_CHAN_TYPE_7_0
:
798 case HDMI_AUD_CHAN_TYPE_7_0_LH_RH
:
799 case HDMI_AUD_CHAN_TYPE_7_0_LSR_RSR
:
800 case HDMI_AUD_CHAN_TYPE_7_0_LC_RC
:
801 case HDMI_AUD_CHAN_TYPE_7_0_LW_RW
:
802 case HDMI_AUD_CHAN_TYPE_7_0_LSD_RSD
:
803 case HDMI_AUD_CHAN_TYPE_7_0_LSS_RSS
:
804 case HDMI_AUD_CHAN_TYPE_7_0_LHS_RHS
:
805 case HDMI_AUD_CHAN_TYPE_7_0_CS_CH
:
806 case HDMI_AUD_CHAN_TYPE_7_0_CS_OH
:
807 case HDMI_AUD_CHAN_TYPE_7_0_CS_CHR
:
808 case HDMI_AUD_CHAN_TYPE_7_0_CH_OH
:
809 case HDMI_AUD_CHAN_TYPE_7_0_CH_CHR
:
810 case HDMI_AUD_CHAN_TYPE_7_0_OH_CHR
:
811 case HDMI_AUD_CHAN_TYPE_7_0_LSS_RSS_LSR_RSR
:
812 case HDMI_AUD_CHAN_TYPE_8_0_LH_RH_CS
:
814 case HDMI_AUD_CHAN_TYPE_7_1
:
815 case HDMI_AUD_CHAN_TYPE_7_1_LH_RH
:
816 case HDMI_AUD_CHAN_TYPE_7_1_LSR_RSR
:
817 case HDMI_AUD_CHAN_TYPE_7_1_LC_RC
:
818 case HDMI_AUD_CHAN_TYPE_7_1_LW_RW
:
819 case HDMI_AUD_CHAN_TYPE_7_1_LSD_RSD
:
820 case HDMI_AUD_CHAN_TYPE_7_1_LSS_RSS
:
821 case HDMI_AUD_CHAN_TYPE_7_1_LHS_RHS
:
822 case HDMI_AUD_CHAN_TYPE_7_1_CS_CH
:
823 case HDMI_AUD_CHAN_TYPE_7_1_CS_OH
:
824 case HDMI_AUD_CHAN_TYPE_7_1_CS_CHR
:
825 case HDMI_AUD_CHAN_TYPE_7_1_CH_OH
:
826 case HDMI_AUD_CHAN_TYPE_7_1_CH_CHR
:
827 case HDMI_AUD_CHAN_TYPE_7_1_OH_CHR
:
828 case HDMI_AUD_CHAN_TYPE_7_1_LSS_RSS_LSR_RSR
:
835 static int mtk_hdmi_video_change_vpll(struct mtk_hdmi
*hdmi
, u32 clock
)
840 /* The DPI driver already should have set TVDPLL to the correct rate */
841 ret
= clk_set_rate(hdmi
->clk
[MTK_HDMI_CLK_HDMI_PLL
], clock
);
843 dev_err(hdmi
->dev
, "Failed to set PLL to %u Hz: %d\n", clock
,
848 rate
= clk_get_rate(hdmi
->clk
[MTK_HDMI_CLK_HDMI_PLL
]);
850 if (DIV_ROUND_CLOSEST(rate
, 1000) != DIV_ROUND_CLOSEST(clock
, 1000))
851 dev_warn(hdmi
->dev
, "Want PLL %u Hz, got %lu Hz\n", clock
,
854 dev_dbg(hdmi
->dev
, "Want PLL %u Hz, got %lu Hz\n", clock
, rate
);
856 mtk_hdmi_hw_config_sys(hdmi
);
857 mtk_hdmi_hw_set_deep_color_mode(hdmi
);
861 static void mtk_hdmi_video_set_display_mode(struct mtk_hdmi
*hdmi
,
862 struct drm_display_mode
*mode
)
864 mtk_hdmi_hw_reset(hdmi
);
865 mtk_hdmi_hw_enable_notice(hdmi
, true);
866 mtk_hdmi_hw_write_int_mask(hdmi
, 0xff);
867 mtk_hdmi_hw_enable_dvi_mode(hdmi
, hdmi
->dvi_mode
);
868 mtk_hdmi_hw_ncts_auto_write_enable(hdmi
, true);
870 mtk_hdmi_hw_msic_setting(hdmi
, mode
);
873 static int mtk_hdmi_aud_enable_packet(struct mtk_hdmi
*hdmi
, bool enable
)
875 mtk_hdmi_hw_send_aud_packet(hdmi
, enable
);
879 static int mtk_hdmi_aud_on_off_hw_ncts(struct mtk_hdmi
*hdmi
, bool on
)
881 mtk_hdmi_hw_ncts_enable(hdmi
, on
);
885 static int mtk_hdmi_aud_set_input(struct mtk_hdmi
*hdmi
)
887 enum hdmi_aud_channel_type chan_type
;
891 mtk_hdmi_hw_aud_set_channel_swap(hdmi
, HDMI_AUD_SWAP_LFE_CC
);
892 mtk_hdmi_set_bits(hdmi
, GRL_MIX_CTRL
, MIX_CTRL_FLAT
);
894 if (hdmi
->aud_param
.aud_input_type
== HDMI_AUD_INPUT_SPDIF
&&
895 hdmi
->aud_param
.aud_codec
== HDMI_AUDIO_CODING_TYPE_DST
) {
896 mtk_hdmi_hw_aud_set_bit_num(hdmi
, HDMI_AUDIO_SAMPLE_SIZE_24
);
897 } else if (hdmi
->aud_param
.aud_i2s_fmt
== HDMI_I2S_MODE_LJT_24BIT
) {
898 hdmi
->aud_param
.aud_i2s_fmt
= HDMI_I2S_MODE_LJT_16BIT
;
901 mtk_hdmi_hw_aud_set_i2s_fmt(hdmi
, hdmi
->aud_param
.aud_i2s_fmt
);
902 mtk_hdmi_hw_aud_set_bit_num(hdmi
, HDMI_AUDIO_SAMPLE_SIZE_24
);
904 dst
= ((hdmi
->aud_param
.aud_input_type
== HDMI_AUD_INPUT_SPDIF
) &&
905 (hdmi
->aud_param
.aud_codec
== HDMI_AUDIO_CODING_TYPE_DST
));
906 mtk_hdmi_hw_audio_config(hdmi
, dst
);
908 if (hdmi
->aud_param
.aud_input_type
== HDMI_AUD_INPUT_SPDIF
)
909 chan_type
= HDMI_AUD_CHAN_TYPE_2_0
;
911 chan_type
= hdmi
->aud_param
.aud_input_chan_type
;
912 chan_count
= mtk_hdmi_aud_get_chnl_count(chan_type
);
913 mtk_hdmi_hw_aud_set_i2s_chan_num(hdmi
, chan_type
, chan_count
);
914 mtk_hdmi_hw_aud_set_input_type(hdmi
, hdmi
->aud_param
.aud_input_type
);
919 static int mtk_hdmi_aud_set_src(struct mtk_hdmi
*hdmi
,
920 struct drm_display_mode
*display_mode
)
922 unsigned int sample_rate
= hdmi
->aud_param
.codec_params
.sample_rate
;
924 mtk_hdmi_aud_on_off_hw_ncts(hdmi
, false);
925 mtk_hdmi_hw_aud_src_disable(hdmi
);
926 mtk_hdmi_clear_bits(hdmi
, GRL_CFG2
, CFG2_ACLK_INV
);
928 if (hdmi
->aud_param
.aud_input_type
== HDMI_AUD_INPUT_I2S
) {
929 switch (sample_rate
) {
939 mtk_hdmi_hw_aud_set_mclk(hdmi
, hdmi
->aud_param
.aud_mclk
);
941 switch (sample_rate
) {
949 mtk_hdmi_hw_aud_set_mclk(hdmi
, HDMI_AUD_MCLK_128FS
);
952 mtk_hdmi_hw_aud_set_ncts(hdmi
, sample_rate
, display_mode
->clock
);
954 mtk_hdmi_hw_aud_src_reenable(hdmi
);
958 static int mtk_hdmi_aud_output_config(struct mtk_hdmi
*hdmi
,
959 struct drm_display_mode
*display_mode
)
961 mtk_hdmi_hw_aud_mute(hdmi
);
962 mtk_hdmi_aud_enable_packet(hdmi
, false);
964 mtk_hdmi_aud_set_input(hdmi
);
965 mtk_hdmi_aud_set_src(hdmi
, display_mode
);
966 mtk_hdmi_hw_aud_set_channel_status(hdmi
,
967 hdmi
->aud_param
.codec_params
.iec
.status
);
969 usleep_range(50, 100);
971 mtk_hdmi_aud_on_off_hw_ncts(hdmi
, true);
972 mtk_hdmi_aud_enable_packet(hdmi
, true);
973 mtk_hdmi_hw_aud_unmute(hdmi
);
977 static int mtk_hdmi_setup_avi_infoframe(struct mtk_hdmi
*hdmi
,
978 struct drm_display_mode
*mode
)
980 struct hdmi_avi_infoframe frame
;
981 u8 buffer
[HDMI_INFOFRAME_HEADER_SIZE
+ HDMI_AVI_INFOFRAME_SIZE
];
984 err
= drm_hdmi_avi_infoframe_from_display_mode(&frame
,
988 "Failed to get AVI infoframe from mode: %zd\n", err
);
992 err
= hdmi_avi_infoframe_pack(&frame
, buffer
, sizeof(buffer
));
994 dev_err(hdmi
->dev
, "Failed to pack AVI infoframe: %zd\n", err
);
998 mtk_hdmi_hw_send_info_frame(hdmi
, buffer
, sizeof(buffer
));
1002 static int mtk_hdmi_setup_spd_infoframe(struct mtk_hdmi
*hdmi
,
1004 const char *product
)
1006 struct hdmi_spd_infoframe frame
;
1007 u8 buffer
[HDMI_INFOFRAME_HEADER_SIZE
+ HDMI_SPD_INFOFRAME_SIZE
];
1010 err
= hdmi_spd_infoframe_init(&frame
, vendor
, product
);
1012 dev_err(hdmi
->dev
, "Failed to initialize SPD infoframe: %zd\n",
1017 err
= hdmi_spd_infoframe_pack(&frame
, buffer
, sizeof(buffer
));
1019 dev_err(hdmi
->dev
, "Failed to pack SDP infoframe: %zd\n", err
);
1023 mtk_hdmi_hw_send_info_frame(hdmi
, buffer
, sizeof(buffer
));
1027 static int mtk_hdmi_setup_audio_infoframe(struct mtk_hdmi
*hdmi
)
1029 struct hdmi_audio_infoframe frame
;
1030 u8 buffer
[HDMI_INFOFRAME_HEADER_SIZE
+ HDMI_AUDIO_INFOFRAME_SIZE
];
1033 err
= hdmi_audio_infoframe_init(&frame
);
1035 dev_err(hdmi
->dev
, "Failed to setup audio infoframe: %zd\n",
1040 frame
.coding_type
= HDMI_AUDIO_CODING_TYPE_STREAM
;
1041 frame
.sample_frequency
= HDMI_AUDIO_SAMPLE_FREQUENCY_STREAM
;
1042 frame
.sample_size
= HDMI_AUDIO_SAMPLE_SIZE_STREAM
;
1043 frame
.channels
= mtk_hdmi_aud_get_chnl_count(
1044 hdmi
->aud_param
.aud_input_chan_type
);
1046 err
= hdmi_audio_infoframe_pack(&frame
, buffer
, sizeof(buffer
));
1048 dev_err(hdmi
->dev
, "Failed to pack audio infoframe: %zd\n",
1053 mtk_hdmi_hw_send_info_frame(hdmi
, buffer
, sizeof(buffer
));
1057 static int mtk_hdmi_setup_vendor_specific_infoframe(struct mtk_hdmi
*hdmi
,
1058 struct drm_display_mode
*mode
)
1060 struct hdmi_vendor_infoframe frame
;
1064 err
= drm_hdmi_vendor_infoframe_from_display_mode(&frame
,
1068 "Failed to get vendor infoframe from mode: %zd\n", err
);
1072 err
= hdmi_vendor_infoframe_pack(&frame
, buffer
, sizeof(buffer
));
1074 dev_err(hdmi
->dev
, "Failed to pack vendor infoframe: %zd\n",
1079 mtk_hdmi_hw_send_info_frame(hdmi
, buffer
, sizeof(buffer
));
1083 static int mtk_hdmi_output_init(struct mtk_hdmi
*hdmi
)
1085 struct hdmi_audio_param
*aud_param
= &hdmi
->aud_param
;
1087 hdmi
->csp
= HDMI_COLORSPACE_RGB
;
1088 aud_param
->aud_codec
= HDMI_AUDIO_CODING_TYPE_PCM
;
1089 aud_param
->aud_sampe_size
= HDMI_AUDIO_SAMPLE_SIZE_16
;
1090 aud_param
->aud_input_type
= HDMI_AUD_INPUT_I2S
;
1091 aud_param
->aud_i2s_fmt
= HDMI_I2S_MODE_I2S_24BIT
;
1092 aud_param
->aud_mclk
= HDMI_AUD_MCLK_128FS
;
1093 aud_param
->aud_input_chan_type
= HDMI_AUD_CHAN_TYPE_2_0
;
1098 static void mtk_hdmi_audio_enable(struct mtk_hdmi
*hdmi
)
1100 mtk_hdmi_aud_enable_packet(hdmi
, true);
1101 hdmi
->audio_enable
= true;
1104 static void mtk_hdmi_audio_disable(struct mtk_hdmi
*hdmi
)
1106 mtk_hdmi_aud_enable_packet(hdmi
, false);
1107 hdmi
->audio_enable
= false;
1110 static int mtk_hdmi_audio_set_param(struct mtk_hdmi
*hdmi
,
1111 struct hdmi_audio_param
*param
)
1113 if (!hdmi
->audio_enable
) {
1114 dev_err(hdmi
->dev
, "hdmi audio is in disable state!\n");
1117 dev_dbg(hdmi
->dev
, "codec:%d, input:%d, channel:%d, fs:%d\n",
1118 param
->aud_codec
, param
->aud_input_type
,
1119 param
->aud_input_chan_type
, param
->codec_params
.sample_rate
);
1120 memcpy(&hdmi
->aud_param
, param
, sizeof(*param
));
1121 return mtk_hdmi_aud_output_config(hdmi
, &hdmi
->mode
);
1124 static int mtk_hdmi_output_set_display_mode(struct mtk_hdmi
*hdmi
,
1125 struct drm_display_mode
*mode
)
1129 mtk_hdmi_hw_vid_black(hdmi
, true);
1130 mtk_hdmi_hw_aud_mute(hdmi
);
1131 mtk_hdmi_hw_send_av_mute(hdmi
);
1132 phy_power_off(hdmi
->phy
);
1134 ret
= mtk_hdmi_video_change_vpll(hdmi
,
1135 mode
->clock
* 1000);
1137 dev_err(hdmi
->dev
, "Failed to set vpll: %d\n", ret
);
1140 mtk_hdmi_video_set_display_mode(hdmi
, mode
);
1142 phy_power_on(hdmi
->phy
);
1143 mtk_hdmi_aud_output_config(hdmi
, mode
);
1145 mtk_hdmi_hw_vid_black(hdmi
, false);
1146 mtk_hdmi_hw_aud_unmute(hdmi
);
1147 mtk_hdmi_hw_send_av_unmute(hdmi
);
1152 static const char * const mtk_hdmi_clk_names
[MTK_HDMI_CLK_COUNT
] = {
1153 [MTK_HDMI_CLK_HDMI_PIXEL
] = "pixel",
1154 [MTK_HDMI_CLK_HDMI_PLL
] = "pll",
1155 [MTK_HDMI_CLK_AUD_BCLK
] = "bclk",
1156 [MTK_HDMI_CLK_AUD_SPDIF
] = "spdif",
1159 static int mtk_hdmi_get_all_clk(struct mtk_hdmi
*hdmi
,
1160 struct device_node
*np
)
1164 for (i
= 0; i
< ARRAY_SIZE(mtk_hdmi_clk_names
); i
++) {
1165 hdmi
->clk
[i
] = of_clk_get_by_name(np
,
1166 mtk_hdmi_clk_names
[i
]);
1167 if (IS_ERR(hdmi
->clk
[i
]))
1168 return PTR_ERR(hdmi
->clk
[i
]);
1173 static int mtk_hdmi_clk_enable_audio(struct mtk_hdmi
*hdmi
)
1177 ret
= clk_prepare_enable(hdmi
->clk
[MTK_HDMI_CLK_AUD_BCLK
]);
1181 ret
= clk_prepare_enable(hdmi
->clk
[MTK_HDMI_CLK_AUD_SPDIF
]);
1187 clk_disable_unprepare(hdmi
->clk
[MTK_HDMI_CLK_AUD_BCLK
]);
1191 static void mtk_hdmi_clk_disable_audio(struct mtk_hdmi
*hdmi
)
1193 clk_disable_unprepare(hdmi
->clk
[MTK_HDMI_CLK_AUD_BCLK
]);
1194 clk_disable_unprepare(hdmi
->clk
[MTK_HDMI_CLK_AUD_SPDIF
]);
1197 static enum drm_connector_status
1198 mtk_hdmi_update_plugged_status(struct mtk_hdmi
*hdmi
)
1202 mutex_lock(&hdmi
->update_plugged_status_lock
);
1203 connected
= mtk_cec_hpd_high(hdmi
->cec_dev
);
1204 if (hdmi
->plugged_cb
&& hdmi
->codec_dev
)
1205 hdmi
->plugged_cb(hdmi
->codec_dev
, connected
);
1206 mutex_unlock(&hdmi
->update_plugged_status_lock
);
1209 connector_status_connected
: connector_status_disconnected
;
1212 static enum drm_connector_status
hdmi_conn_detect(struct drm_connector
*conn
,
1215 struct mtk_hdmi
*hdmi
= hdmi_ctx_from_conn(conn
);
1216 return mtk_hdmi_update_plugged_status(hdmi
);
1219 static void hdmi_conn_destroy(struct drm_connector
*conn
)
1221 struct mtk_hdmi
*hdmi
= hdmi_ctx_from_conn(conn
);
1223 mtk_cec_set_hpd_event(hdmi
->cec_dev
, NULL
, NULL
);
1225 drm_connector_cleanup(conn
);
1228 static int mtk_hdmi_conn_get_modes(struct drm_connector
*conn
)
1230 struct mtk_hdmi
*hdmi
= hdmi_ctx_from_conn(conn
);
1234 if (!hdmi
->ddc_adpt
)
1237 edid
= drm_get_edid(conn
, hdmi
->ddc_adpt
);
1241 hdmi
->dvi_mode
= !drm_detect_monitor_audio(edid
);
1243 drm_connector_update_edid_property(conn
, edid
);
1245 ret
= drm_add_edid_modes(conn
, edid
);
1250 static int mtk_hdmi_conn_mode_valid(struct drm_connector
*conn
,
1251 struct drm_display_mode
*mode
)
1253 struct mtk_hdmi
*hdmi
= hdmi_ctx_from_conn(conn
);
1254 struct drm_bridge
*next_bridge
;
1256 dev_dbg(hdmi
->dev
, "xres=%d, yres=%d, refresh=%d, intl=%d clock=%d\n",
1257 mode
->hdisplay
, mode
->vdisplay
, drm_mode_vrefresh(mode
),
1258 !!(mode
->flags
& DRM_MODE_FLAG_INTERLACE
), mode
->clock
* 1000);
1260 next_bridge
= drm_bridge_get_next_bridge(&hdmi
->bridge
);
1262 struct drm_display_mode adjusted_mode
;
1264 drm_mode_copy(&adjusted_mode
, mode
);
1265 if (!drm_bridge_chain_mode_fixup(next_bridge
, mode
,
1270 if (mode
->clock
< 27000)
1271 return MODE_CLOCK_LOW
;
1272 if (mode
->clock
> 297000)
1273 return MODE_CLOCK_HIGH
;
1275 return drm_mode_validate_size(mode
, 0x1fff, 0x1fff);
1278 static struct drm_encoder
*mtk_hdmi_conn_best_enc(struct drm_connector
*conn
)
1280 struct mtk_hdmi
*hdmi
= hdmi_ctx_from_conn(conn
);
1282 return hdmi
->bridge
.encoder
;
1285 static const struct drm_connector_funcs mtk_hdmi_connector_funcs
= {
1286 .detect
= hdmi_conn_detect
,
1287 .fill_modes
= drm_helper_probe_single_connector_modes
,
1288 .destroy
= hdmi_conn_destroy
,
1289 .reset
= drm_atomic_helper_connector_reset
,
1290 .atomic_duplicate_state
= drm_atomic_helper_connector_duplicate_state
,
1291 .atomic_destroy_state
= drm_atomic_helper_connector_destroy_state
,
1294 static const struct drm_connector_helper_funcs
1295 mtk_hdmi_connector_helper_funcs
= {
1296 .get_modes
= mtk_hdmi_conn_get_modes
,
1297 .mode_valid
= mtk_hdmi_conn_mode_valid
,
1298 .best_encoder
= mtk_hdmi_conn_best_enc
,
1301 static void mtk_hdmi_hpd_event(bool hpd
, struct device
*dev
)
1303 struct mtk_hdmi
*hdmi
= dev_get_drvdata(dev
);
1305 if (hdmi
&& hdmi
->bridge
.encoder
&& hdmi
->bridge
.encoder
->dev
)
1306 drm_helper_hpd_irq_event(hdmi
->bridge
.encoder
->dev
);
1313 static int mtk_hdmi_bridge_attach(struct drm_bridge
*bridge
,
1314 enum drm_bridge_attach_flags flags
)
1316 struct mtk_hdmi
*hdmi
= hdmi_ctx_from_bridge(bridge
);
1319 if (flags
& DRM_BRIDGE_ATTACH_NO_CONNECTOR
) {
1320 DRM_ERROR("Fix bridge driver to make connector optional!");
1324 ret
= drm_connector_init_with_ddc(bridge
->encoder
->dev
, &hdmi
->conn
,
1325 &mtk_hdmi_connector_funcs
,
1326 DRM_MODE_CONNECTOR_HDMIA
,
1329 dev_err(hdmi
->dev
, "Failed to initialize connector: %d\n", ret
);
1332 drm_connector_helper_add(&hdmi
->conn
, &mtk_hdmi_connector_helper_funcs
);
1334 hdmi
->conn
.polled
= DRM_CONNECTOR_POLL_HPD
;
1335 hdmi
->conn
.interlace_allowed
= true;
1336 hdmi
->conn
.doublescan_allowed
= false;
1338 ret
= drm_connector_attach_encoder(&hdmi
->conn
,
1342 "Failed to attach connector to encoder: %d\n", ret
);
1346 if (hdmi
->next_bridge
) {
1347 ret
= drm_bridge_attach(bridge
->encoder
, hdmi
->next_bridge
,
1351 "Failed to attach external bridge: %d\n", ret
);
1356 mtk_cec_set_hpd_event(hdmi
->cec_dev
, mtk_hdmi_hpd_event
, hdmi
->dev
);
1361 static bool mtk_hdmi_bridge_mode_fixup(struct drm_bridge
*bridge
,
1362 const struct drm_display_mode
*mode
,
1363 struct drm_display_mode
*adjusted_mode
)
1368 static void mtk_hdmi_bridge_disable(struct drm_bridge
*bridge
)
1370 struct mtk_hdmi
*hdmi
= hdmi_ctx_from_bridge(bridge
);
1375 phy_power_off(hdmi
->phy
);
1376 clk_disable_unprepare(hdmi
->clk
[MTK_HDMI_CLK_HDMI_PIXEL
]);
1377 clk_disable_unprepare(hdmi
->clk
[MTK_HDMI_CLK_HDMI_PLL
]);
1379 hdmi
->enabled
= false;
1382 static void mtk_hdmi_bridge_post_disable(struct drm_bridge
*bridge
)
1384 struct mtk_hdmi
*hdmi
= hdmi_ctx_from_bridge(bridge
);
1389 mtk_hdmi_hw_1p4_version_enable(hdmi
, true);
1390 mtk_hdmi_hw_make_reg_writable(hdmi
, false);
1392 hdmi
->powered
= false;
1395 static void mtk_hdmi_bridge_mode_set(struct drm_bridge
*bridge
,
1396 const struct drm_display_mode
*mode
,
1397 const struct drm_display_mode
*adjusted_mode
)
1399 struct mtk_hdmi
*hdmi
= hdmi_ctx_from_bridge(bridge
);
1401 dev_dbg(hdmi
->dev
, "cur info: name:%s, hdisplay:%d\n",
1402 adjusted_mode
->name
, adjusted_mode
->hdisplay
);
1403 dev_dbg(hdmi
->dev
, "hsync_start:%d,hsync_end:%d, htotal:%d",
1404 adjusted_mode
->hsync_start
, adjusted_mode
->hsync_end
,
1405 adjusted_mode
->htotal
);
1406 dev_dbg(hdmi
->dev
, "hskew:%d, vdisplay:%d\n",
1407 adjusted_mode
->hskew
, adjusted_mode
->vdisplay
);
1408 dev_dbg(hdmi
->dev
, "vsync_start:%d, vsync_end:%d, vtotal:%d",
1409 adjusted_mode
->vsync_start
, adjusted_mode
->vsync_end
,
1410 adjusted_mode
->vtotal
);
1411 dev_dbg(hdmi
->dev
, "vscan:%d, flag:%d\n",
1412 adjusted_mode
->vscan
, adjusted_mode
->flags
);
1414 drm_mode_copy(&hdmi
->mode
, adjusted_mode
);
1417 static void mtk_hdmi_bridge_pre_enable(struct drm_bridge
*bridge
)
1419 struct mtk_hdmi
*hdmi
= hdmi_ctx_from_bridge(bridge
);
1421 mtk_hdmi_hw_make_reg_writable(hdmi
, true);
1422 mtk_hdmi_hw_1p4_version_enable(hdmi
, true);
1424 hdmi
->powered
= true;
1427 static void mtk_hdmi_send_infoframe(struct mtk_hdmi
*hdmi
,
1428 struct drm_display_mode
*mode
)
1430 mtk_hdmi_setup_audio_infoframe(hdmi
);
1431 mtk_hdmi_setup_avi_infoframe(hdmi
, mode
);
1432 mtk_hdmi_setup_spd_infoframe(hdmi
, "mediatek", "On-chip HDMI");
1433 if (mode
->flags
& DRM_MODE_FLAG_3D_MASK
)
1434 mtk_hdmi_setup_vendor_specific_infoframe(hdmi
, mode
);
1437 static void mtk_hdmi_bridge_enable(struct drm_bridge
*bridge
)
1439 struct mtk_hdmi
*hdmi
= hdmi_ctx_from_bridge(bridge
);
1441 mtk_hdmi_output_set_display_mode(hdmi
, &hdmi
->mode
);
1442 clk_prepare_enable(hdmi
->clk
[MTK_HDMI_CLK_HDMI_PLL
]);
1443 clk_prepare_enable(hdmi
->clk
[MTK_HDMI_CLK_HDMI_PIXEL
]);
1444 phy_power_on(hdmi
->phy
);
1445 mtk_hdmi_send_infoframe(hdmi
, &hdmi
->mode
);
1447 hdmi
->enabled
= true;
1450 static const struct drm_bridge_funcs mtk_hdmi_bridge_funcs
= {
1451 .attach
= mtk_hdmi_bridge_attach
,
1452 .mode_fixup
= mtk_hdmi_bridge_mode_fixup
,
1453 .disable
= mtk_hdmi_bridge_disable
,
1454 .post_disable
= mtk_hdmi_bridge_post_disable
,
1455 .mode_set
= mtk_hdmi_bridge_mode_set
,
1456 .pre_enable
= mtk_hdmi_bridge_pre_enable
,
1457 .enable
= mtk_hdmi_bridge_enable
,
1460 static int mtk_hdmi_dt_parse_pdata(struct mtk_hdmi
*hdmi
,
1461 struct platform_device
*pdev
)
1463 struct device
*dev
= &pdev
->dev
;
1464 struct device_node
*np
= dev
->of_node
;
1465 struct device_node
*cec_np
, *remote
, *i2c_np
;
1466 struct platform_device
*cec_pdev
;
1467 struct regmap
*regmap
;
1468 struct resource
*mem
;
1471 ret
= mtk_hdmi_get_all_clk(hdmi
, np
);
1473 if (ret
!= -EPROBE_DEFER
)
1474 dev_err(dev
, "Failed to get clocks: %d\n", ret
);
1479 /* The CEC module handles HDMI hotplug detection */
1480 cec_np
= of_get_compatible_child(np
->parent
, "mediatek,mt8173-cec");
1482 dev_err(dev
, "Failed to find CEC node\n");
1486 cec_pdev
= of_find_device_by_node(cec_np
);
1488 dev_err(hdmi
->dev
, "Waiting for CEC device %pOF\n",
1490 of_node_put(cec_np
);
1491 return -EPROBE_DEFER
;
1493 of_node_put(cec_np
);
1494 hdmi
->cec_dev
= &cec_pdev
->dev
;
1497 * The mediatek,syscon-hdmi property contains a phandle link to the
1498 * MMSYS_CONFIG device and the register offset of the HDMI_SYS_CFG
1499 * registers it contains.
1501 regmap
= syscon_regmap_lookup_by_phandle(np
, "mediatek,syscon-hdmi");
1502 ret
= of_property_read_u32_index(np
, "mediatek,syscon-hdmi", 1,
1505 ret
= PTR_ERR(regmap
);
1508 "Failed to get system configuration registers: %d\n",
1512 hdmi
->sys_regmap
= regmap
;
1514 mem
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
1515 hdmi
->regs
= devm_ioremap_resource(dev
, mem
);
1516 if (IS_ERR(hdmi
->regs
))
1517 return PTR_ERR(hdmi
->regs
);
1519 remote
= of_graph_get_remote_node(np
, 1, 0);
1523 if (!of_device_is_compatible(remote
, "hdmi-connector")) {
1524 hdmi
->next_bridge
= of_drm_find_bridge(remote
);
1525 if (!hdmi
->next_bridge
) {
1526 dev_err(dev
, "Waiting for external bridge\n");
1527 of_node_put(remote
);
1528 return -EPROBE_DEFER
;
1532 i2c_np
= of_parse_phandle(remote
, "ddc-i2c-bus", 0);
1534 dev_err(dev
, "Failed to find ddc-i2c-bus node in %pOF\n",
1536 of_node_put(remote
);
1539 of_node_put(remote
);
1541 hdmi
->ddc_adpt
= of_find_i2c_adapter_by_node(i2c_np
);
1542 of_node_put(i2c_np
);
1543 if (!hdmi
->ddc_adpt
) {
1544 dev_err(dev
, "Failed to get ddc i2c adapter by node\n");
1552 * HDMI audio codec callbacks
1555 static int mtk_hdmi_audio_hw_params(struct device
*dev
, void *data
,
1556 struct hdmi_codec_daifmt
*daifmt
,
1557 struct hdmi_codec_params
*params
)
1559 struct mtk_hdmi
*hdmi
= dev_get_drvdata(dev
);
1560 struct hdmi_audio_param hdmi_params
;
1561 unsigned int chan
= params
->cea
.channels
;
1563 dev_dbg(hdmi
->dev
, "%s: %u Hz, %d bit, %d channels\n", __func__
,
1564 params
->sample_rate
, params
->sample_width
, chan
);
1566 if (!hdmi
->bridge
.encoder
)
1571 hdmi_params
.aud_input_chan_type
= HDMI_AUD_CHAN_TYPE_2_0
;
1574 hdmi_params
.aud_input_chan_type
= HDMI_AUD_CHAN_TYPE_4_0
;
1577 hdmi_params
.aud_input_chan_type
= HDMI_AUD_CHAN_TYPE_5_1
;
1580 hdmi_params
.aud_input_chan_type
= HDMI_AUD_CHAN_TYPE_7_1
;
1583 dev_err(hdmi
->dev
, "channel[%d] not supported!\n", chan
);
1587 switch (params
->sample_rate
) {
1597 dev_err(hdmi
->dev
, "rate[%d] not supported!\n",
1598 params
->sample_rate
);
1602 switch (daifmt
->fmt
) {
1604 hdmi_params
.aud_codec
= HDMI_AUDIO_CODING_TYPE_PCM
;
1605 hdmi_params
.aud_sampe_size
= HDMI_AUDIO_SAMPLE_SIZE_16
;
1606 hdmi_params
.aud_input_type
= HDMI_AUD_INPUT_I2S
;
1607 hdmi_params
.aud_i2s_fmt
= HDMI_I2S_MODE_I2S_24BIT
;
1608 hdmi_params
.aud_mclk
= HDMI_AUD_MCLK_128FS
;
1611 hdmi_params
.aud_codec
= HDMI_AUDIO_CODING_TYPE_PCM
;
1612 hdmi_params
.aud_sampe_size
= HDMI_AUDIO_SAMPLE_SIZE_16
;
1613 hdmi_params
.aud_input_type
= HDMI_AUD_INPUT_SPDIF
;
1616 dev_err(hdmi
->dev
, "%s: Invalid DAI format %d\n", __func__
,
1621 memcpy(&hdmi_params
.codec_params
, params
,
1622 sizeof(hdmi_params
.codec_params
));
1624 mtk_hdmi_audio_set_param(hdmi
, &hdmi_params
);
1629 static int mtk_hdmi_audio_startup(struct device
*dev
, void *data
)
1631 struct mtk_hdmi
*hdmi
= dev_get_drvdata(dev
);
1633 dev_dbg(dev
, "%s\n", __func__
);
1635 mtk_hdmi_audio_enable(hdmi
);
1640 static void mtk_hdmi_audio_shutdown(struct device
*dev
, void *data
)
1642 struct mtk_hdmi
*hdmi
= dev_get_drvdata(dev
);
1644 dev_dbg(dev
, "%s\n", __func__
);
1646 mtk_hdmi_audio_disable(hdmi
);
1650 mtk_hdmi_audio_digital_mute(struct device
*dev
, void *data
, bool enable
)
1652 struct mtk_hdmi
*hdmi
= dev_get_drvdata(dev
);
1654 dev_dbg(dev
, "%s(%d)\n", __func__
, enable
);
1657 mtk_hdmi_hw_aud_mute(hdmi
);
1659 mtk_hdmi_hw_aud_unmute(hdmi
);
1664 static int mtk_hdmi_audio_get_eld(struct device
*dev
, void *data
, uint8_t *buf
, size_t len
)
1666 struct mtk_hdmi
*hdmi
= dev_get_drvdata(dev
);
1668 dev_dbg(dev
, "%s\n", __func__
);
1670 memcpy(buf
, hdmi
->conn
.eld
, min(sizeof(hdmi
->conn
.eld
), len
));
1675 static int mtk_hdmi_audio_hook_plugged_cb(struct device
*dev
, void *data
,
1676 hdmi_codec_plugged_cb fn
,
1677 struct device
*codec_dev
)
1679 struct mtk_hdmi
*hdmi
= data
;
1681 mutex_lock(&hdmi
->update_plugged_status_lock
);
1682 hdmi
->plugged_cb
= fn
;
1683 hdmi
->codec_dev
= codec_dev
;
1684 mutex_unlock(&hdmi
->update_plugged_status_lock
);
1686 mtk_hdmi_update_plugged_status(hdmi
);
1691 static const struct hdmi_codec_ops mtk_hdmi_audio_codec_ops
= {
1692 .hw_params
= mtk_hdmi_audio_hw_params
,
1693 .audio_startup
= mtk_hdmi_audio_startup
,
1694 .audio_shutdown
= mtk_hdmi_audio_shutdown
,
1695 .digital_mute
= mtk_hdmi_audio_digital_mute
,
1696 .get_eld
= mtk_hdmi_audio_get_eld
,
1697 .hook_plugged_cb
= mtk_hdmi_audio_hook_plugged_cb
,
1700 static int mtk_hdmi_register_audio_driver(struct device
*dev
)
1702 struct mtk_hdmi
*hdmi
= dev_get_drvdata(dev
);
1703 struct hdmi_codec_pdata codec_data
= {
1704 .ops
= &mtk_hdmi_audio_codec_ops
,
1705 .max_i2s_channels
= 2,
1709 struct platform_device
*pdev
;
1711 pdev
= platform_device_register_data(dev
, HDMI_CODEC_DRV_NAME
,
1712 PLATFORM_DEVID_AUTO
, &codec_data
,
1713 sizeof(codec_data
));
1715 return PTR_ERR(pdev
);
1717 DRM_INFO("%s driver bound to HDMI\n", HDMI_CODEC_DRV_NAME
);
1721 static int mtk_drm_hdmi_probe(struct platform_device
*pdev
)
1723 struct mtk_hdmi
*hdmi
;
1724 struct device
*dev
= &pdev
->dev
;
1727 hdmi
= devm_kzalloc(dev
, sizeof(*hdmi
), GFP_KERNEL
);
1733 ret
= mtk_hdmi_dt_parse_pdata(hdmi
, pdev
);
1737 hdmi
->phy
= devm_phy_get(dev
, "hdmi");
1738 if (IS_ERR(hdmi
->phy
)) {
1739 ret
= PTR_ERR(hdmi
->phy
);
1740 dev_err(dev
, "Failed to get HDMI PHY: %d\n", ret
);
1744 mutex_init(&hdmi
->update_plugged_status_lock
);
1745 platform_set_drvdata(pdev
, hdmi
);
1747 ret
= mtk_hdmi_output_init(hdmi
);
1749 dev_err(dev
, "Failed to initialize hdmi output\n");
1753 ret
= mtk_hdmi_register_audio_driver(dev
);
1755 dev_err(dev
, "Failed to register audio driver: %d\n", ret
);
1759 hdmi
->bridge
.funcs
= &mtk_hdmi_bridge_funcs
;
1760 hdmi
->bridge
.of_node
= pdev
->dev
.of_node
;
1761 drm_bridge_add(&hdmi
->bridge
);
1763 ret
= mtk_hdmi_clk_enable_audio(hdmi
);
1765 dev_err(dev
, "Failed to enable audio clocks: %d\n", ret
);
1766 goto err_bridge_remove
;
1769 dev_dbg(dev
, "mediatek hdmi probe success\n");
1773 drm_bridge_remove(&hdmi
->bridge
);
1777 static int mtk_drm_hdmi_remove(struct platform_device
*pdev
)
1779 struct mtk_hdmi
*hdmi
= platform_get_drvdata(pdev
);
1781 drm_bridge_remove(&hdmi
->bridge
);
1782 mtk_hdmi_clk_disable_audio(hdmi
);
1786 #ifdef CONFIG_PM_SLEEP
1787 static int mtk_hdmi_suspend(struct device
*dev
)
1789 struct mtk_hdmi
*hdmi
= dev_get_drvdata(dev
);
1791 mtk_hdmi_clk_disable_audio(hdmi
);
1792 dev_dbg(dev
, "hdmi suspend success!\n");
1796 static int mtk_hdmi_resume(struct device
*dev
)
1798 struct mtk_hdmi
*hdmi
= dev_get_drvdata(dev
);
1801 ret
= mtk_hdmi_clk_enable_audio(hdmi
);
1803 dev_err(dev
, "hdmi resume failed!\n");
1807 dev_dbg(dev
, "hdmi resume success!\n");
1811 static SIMPLE_DEV_PM_OPS(mtk_hdmi_pm_ops
,
1812 mtk_hdmi_suspend
, mtk_hdmi_resume
);
1814 static const struct of_device_id mtk_drm_hdmi_of_ids
[] = {
1815 { .compatible
= "mediatek,mt8173-hdmi", },
1819 static struct platform_driver mtk_hdmi_driver
= {
1820 .probe
= mtk_drm_hdmi_probe
,
1821 .remove
= mtk_drm_hdmi_remove
,
1823 .name
= "mediatek-drm-hdmi",
1824 .of_match_table
= mtk_drm_hdmi_of_ids
,
1825 .pm
= &mtk_hdmi_pm_ops
,
1829 static struct platform_driver
* const mtk_hdmi_drivers
[] = {
1830 &mtk_hdmi_phy_driver
,
1831 &mtk_hdmi_ddc_driver
,
1836 static int __init
mtk_hdmitx_init(void)
1838 return platform_register_drivers(mtk_hdmi_drivers
,
1839 ARRAY_SIZE(mtk_hdmi_drivers
));
1842 static void __exit
mtk_hdmitx_exit(void)
1844 platform_unregister_drivers(mtk_hdmi_drivers
,
1845 ARRAY_SIZE(mtk_hdmi_drivers
));
1848 module_init(mtk_hdmitx_init
);
1849 module_exit(mtk_hdmitx_exit
);
1851 MODULE_AUTHOR("Jie Qiu <jie.qiu@mediatek.com>");
1852 MODULE_DESCRIPTION("MediaTek HDMI Driver");
1853 MODULE_LICENSE("GPL v2");