~hc/RK356X_SDK_RELEASE.git

..	..	@@ -1,49 +1,46 @@
	1	+// SPDX-License-Identifier: GPL-2.0-or-later
1	2	/*
2	3	* DesignWare High-Definition Multimedia Interface (HDMI) driver
3	4	*
4	5	* Copyright (C) 2013-2015 Mentor Graphics Inc.
5	6	* Copyright (C) 2011-2013 Freescale Semiconductor, Inc.
6	7	* Copyright (C) 2010, Guennadi Liakhovetski <g.liakhovetski@gmx.de>
7		- *
8		- * This program is free software; you can redistribute it and/or modify
9		- * it under the terms of the GNU General Public License as published by
10		- * the Free Software Foundation; either version 2 of the License, or
11		- * (at your option) any later version.
12		- *
13	8	*/
14		-#include <linux/module.h>
15		-#include <linux/irq.h>
	9	+#include <linux/clk.h>
16	10	#include <linux/delay.h>
17	11	#include <linux/err.h>
18	12	#include <linux/extcon.h>
19	13	#include <linux/extcon-provider.h>
20		-#include <linux/clk.h>
21	14	#include <linux/hdmi.h>
	15	+#include <linux/irq.h>
	16	+#include <linux/module.h>
22	17	#include <linux/mutex.h>
23	18	#include <linux/of_device.h>
	19	+#include <linux/pinctrl/consumer.h>
24	20	#include <linux/regmap.h>
	21	+#include <linux/dma-mapping.h>
25	22	#include <linux/spinlock.h>
26	23	#include <linux/pinctrl/consumer.h>
27	24
28		-#include <drm/drm_of.h>
29		-#include <drm/drmP.h>
30		-#include <drm/drm_atomic.h>
31		-#include <drm/drm_atomic_helper.h>
32		-#include <drm/drm_crtc_helper.h>
33		-#include <drm/drm_edid.h>
34		-#include <drm/drm_encoder_slave.h>
35		-#include <drm/drm_scdc_helper.h>
36		-#include <drm/bridge/dw_hdmi.h>
	25	+#include <media/cec-notifier.h>
37	26
38	27	#include <uapi/linux/media-bus-format.h>
39	28	#include <uapi/linux/videodev2.h>
40	29
41		-#include "dw-hdmi.h"
	30	+#include <drm/bridge/dw_hdmi.h>
	31	+#include <drm/drm_atomic.h>
	32	+#include <drm/drm_atomic_helper.h>
	33	+#include <drm/drm_bridge.h>
	34	+#include <drm/drm_edid.h>
	35	+#include <drm/drm_of.h>
	36	+#include <drm/drm_print.h>
	37	+#include <drm/drm_probe_helper.h>
	38	+#include <drm/drm_scdc_helper.h>
	39	+
42	40	#include "dw-hdmi-audio.h"
43	41	#include "dw-hdmi-cec.h"
44	42	#include "dw-hdmi-hdcp.h"
45		-
46		-#include <media/cec-notifier.h>
	43	+#include "dw-hdmi.h"
47	44
48	45	#define DDC_CI_ADDR 0x37
49	46	#define DDC_SEGMENT_ADDR 0x30
..	..	@@ -150,56 +147,20 @@
150	147
151	148	static const u16 csc_coeff_rgb_in_eitu601[3][4] = {
152	149	{ 0x2591, 0x1322, 0x074b, 0x0000 },
153		- { 0xe535, 0x2000, 0xfacc, 0x0200 },
154		- { 0xeacd, 0xf534, 0x2000, 0x0200 }
155		-};
156		-
157		-static const u16 csc_coeff_rgb_in_eitu601_10bit[3][4] = {
158		- { 0x2591, 0x1322, 0x074b, 0x0000 },
159		- { 0xe535, 0x2000, 0xfacc, 0x0800 },
160		- { 0xeacd, 0xf534, 0x2000, 0x0800 }
161		-};
162		-
163		-static const u16 csc_coeff_rgb_in_eitu601_limited[3][4] = {
164		- { 0x2044, 0x106f, 0x0644, 0x0040 },
165		- { 0xe677, 0x1c1c, 0xfd46, 0x0200 },
166		- { 0xed60, 0xf685, 0x1c1c, 0x0200 }
167		-};
168		-
169		-static const u16 csc_coeff_rgb_in_eitu601_10bit_limited[3][4] = {
170		- { 0x2044, 0x106f, 0x0644, 0x0100 },
171		- { 0xe677, 0x1c1c, 0xfd46, 0x0800 },
172		- { 0xed60, 0xf685, 0x1c1c, 0x0800 }
	150	+ { 0x6535, 0x2000, 0x7acc, 0x0200 },
	151	+ { 0x6acd, 0x7534, 0x2000, 0x0200 }
173	152	};
174	153
175	154	static const u16 csc_coeff_rgb_in_eitu709[3][4] = {
176	155	{ 0x2dc5, 0x0d9b, 0x049e, 0x0000 },
177		- { 0xe2f0, 0x2000, 0xfd11, 0x0200 },
178		- { 0xe756, 0xf8ab, 0x2000, 0x0200 }
	156	+ { 0x62f0, 0x2000, 0x7d11, 0x0200 },
	157	+ { 0x6756, 0x78ab, 0x2000, 0x0200 }
179	158	};
180	159
181		-static const u16 csc_coeff_rgb_in_eitu709_10bit[3][4] = {
182		- { 0x2dc5, 0x0d9b, 0x049e, 0x0000 },
183		- { 0xe2f0, 0x2000, 0xfd11, 0x0800 },
184		- { 0xe756, 0xf8ab, 0x2000, 0x0800 }
185		-};
186		-
187		-static const u16 csc_coeff_rgb_in_eitu709_limited[3][4] = {
188		- { 0x2750, 0x0baf, 0x03f8, 0x0040 },
189		- { 0xe677, 0x1c1c, 0xfd6d, 0x0200 },
190		- { 0xea55, 0xf98f, 0x1c1c, 0x0200 }
191		-};
192		-
193		-static const u16 csc_coeff_rgb_in_eitu709_10bit_limited[3][4] = {
194		- { 0x2750, 0x0baf, 0x03f8, 0x0100 },
195		- { 0xe677, 0x1c1c, 0xfd6d, 0x0800 },
196		- { 0xea55, 0xf98f, 0x1c1c, 0x0800 }
197		-};
198		-
199		-static const u16 csc_coeff_full_to_limited[3][4] = {
200		- { 0x36f7, 0x0000, 0x0000, 0x0040 },
201		- { 0x0000, 0x36f7, 0x0000, 0x0040 },
202		- { 0x0000, 0x0000, 0x36f7, 0x0040 }
	160	+static const u16 csc_coeff_rgb_full_to_rgb_limited[3][4] = {
	161	+ { 0x1b7c, 0x0000, 0x0000, 0x0020 },
	162	+ { 0x0000, 0x1b7c, 0x0000, 0x0020 },
	163	+ { 0x0000, 0x0000, 0x1b7c, 0x0020 }
203	164	};
204	165
205	166	static const struct drm_display_mode dw_hdmi_default_modes[] = {
..	..	@@ -207,36 +168,32 @@
207	168	{ DRM_MODE("1280x720", DRM_MODE_TYPE_DRIVER, 74250, 1280, 1390,
208	169	1430, 1650, 0, 720, 725, 730, 750, 0,
209	170	DRM_MODE_FLAG_PHSYNC \| DRM_MODE_FLAG_PVSYNC),
210		- .vrefresh = 60, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9, },
	171	+ .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9, },
211	172	/* 16 - 1920x1080@60Hz 16:9 */
212	173	{ DRM_MODE("1920x1080", DRM_MODE_TYPE_DRIVER, 148500, 1920, 2008,
213	174	2052, 2200, 0, 1080, 1084, 1089, 1125, 0,
214	175	DRM_MODE_FLAG_PHSYNC \| DRM_MODE_FLAG_PVSYNC),
215		- .vrefresh = 60, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9, },
	176	+ .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9, },
216	177	/* 31 - 1920x1080@50Hz 16:9 */
217	178	{ DRM_MODE("1920x1080", DRM_MODE_TYPE_DRIVER, 148500, 1920, 2448,
218	179	2492, 2640, 0, 1080, 1084, 1089, 1125, 0,
219	180	DRM_MODE_FLAG_PHSYNC \| DRM_MODE_FLAG_PVSYNC),
220		- .vrefresh = 50, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9, },
	181	+ .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9, },
221	182	/* 19 - 1280x720@50Hz 16:9 */
222	183	{ DRM_MODE("1280x720", DRM_MODE_TYPE_DRIVER, 74250, 1280, 1720,
223	184	1760, 1980, 0, 720, 725, 730, 750, 0,
224	185	DRM_MODE_FLAG_PHSYNC \| DRM_MODE_FLAG_PVSYNC),
225		- .vrefresh = 50, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9, },
226		- /* 0x10 - 1024x768@60Hz */
227		- { DRM_MODE("1024x768", DRM_MODE_TYPE_DRIVER, 65000, 1024, 1048,
228		- 1184, 1344, 0, 768, 771, 777, 806, 0,
229		- DRM_MODE_FLAG_NHSYNC \| DRM_MODE_FLAG_NVSYNC) },
	186	+ .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9, },
230	187	/* 17 - 720x576@50Hz 4:3 */
231	188	{ DRM_MODE("720x576", DRM_MODE_TYPE_DRIVER, 27000, 720, 732,
232	189	796, 864, 0, 576, 581, 586, 625, 0,
233	190	DRM_MODE_FLAG_NHSYNC \| DRM_MODE_FLAG_NVSYNC),
234		- .vrefresh = 50, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_4_3, },
	191	+ .picture_aspect_ratio = HDMI_PICTURE_ASPECT_4_3, },
235	192	/* 2 - 720x480@60Hz 4:3 */
236	193	{ DRM_MODE("720x480", DRM_MODE_TYPE_DRIVER, 27000, 720, 736,
237	194	798, 858, 0, 480, 489, 495, 525, 0,
238	195	DRM_MODE_FLAG_NHSYNC \| DRM_MODE_FLAG_NVSYNC),
239		- .vrefresh = 60, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_4_3, },
	196	+ .picture_aspect_ratio = HDMI_PICTURE_ASPECT_4_3, },
240	197	};
241	198
242	199	struct hdmi_vmode {
..	..	@@ -258,7 +215,7 @@
258	215	unsigned int quant_range;
259	216	unsigned int pix_repet_factor;
260	217	struct hdmi_vmode video_mode;
261		- bool update;
	218	+ bool rgb_limited_range;
262	219	};
263	220
264	221	struct dw_hdmi_i2c {
..	..	@@ -304,6 +261,7 @@
304	261
305	262	struct hdmi_data_info hdmi_data;
306	263	const struct dw_hdmi_plat_data *plat_data;
	264	+ const struct dw_hdmi_cec_wake_ops *cec_ops;
307	265	struct dw_hdcp *hdcp;
308	266
309	267	int vic;
..	..	@@ -321,7 +279,6 @@
321	279	struct drm_display_mode previous_mode;
322	280
323	281	struct i2c_adapter *ddc;
324		- struct cec_adapter *cec_adap;
325	282	void __iomem *regs;
326	283	bool sink_is_hdmi;
327	284	bool sink_has_audio;
..	..	@@ -333,8 +290,13 @@
333	290	struct delayed_work work;
334	291	struct workqueue_struct *workqueue;
335	292
	293	+ struct pinctrl *pinctrl;
	294	+ struct pinctrl_state *default_state;
	295	+ struct pinctrl_state *unwedge_state;
	296	+
336	297	struct mutex mutex; /* for state below and previous_mode */
337	298	enum drm_connector_force force; /* mutex-protected force state */
	299	+ struct drm_connector curr_conn;/ current connector (only valid when !disabled) */
338	300	bool disabled; /* DRM has disabled our bridge */
339	301	bool bridge_is_on; /* indicates the bridge is on */
340	302	bool rxsense; /* rxsense state */
..	..	@@ -357,14 +319,15 @@
357	319	void (enable_audio)(struct dw_hdmi hdmi);
358	320	void (disable_audio)(struct dw_hdmi hdmi);
359	321
	322	+ struct mutex cec_notifier_mutex;
360	323	struct cec_notifier *cec_notifier;
	324	+ struct cec_adapter *cec_adap;
361	325
362		- bool initialized; /* hdmi is enabled before bind */
363		- bool logo_plug_out; /* hdmi is plug out when kernel logo */
364	326	hdmi_codec_plugged_cb plugged_cb;
365	327	struct device *codec_dev;
366	328	enum drm_connector_status last_connector_result;
367		- bool rgb_quant_range_selectable;
	329	+ bool initialized; /* hdmi is enabled before bind */
	330	+ bool logo_plug_out; /* hdmi is plug out when kernel logo */
368	331	bool update;
369	332	bool hdr2sdr; /* from hdr to sdr */
370	333	};
..	..	@@ -446,6 +409,8 @@
446	409	static void repo_hpd_event(struct work_struct *p_work)
447	410	{
448	411	struct dw_hdmi *hdmi = container_of(p_work, struct dw_hdmi, work.work);
	412	+ enum drm_connector_status status = hdmi->hpd_state ?
	413	+ connector_status_connected : connector_status_disconnected;
449	414	u8 phy_stat = hdmi_readb(hdmi, HDMI_PHY_STAT0);
450	415
451	416	mutex_lock(&hdmi->mutex);
..	..	@@ -460,13 +425,12 @@
460	425
461	426	change = drm_helper_hpd_irq_event(hdmi->bridge.dev);
462	427
463		-#ifdef CONFIG_CEC_NOTIFIER
464		- if (change) {
465		- cec_notifier_repo_cec_hpd(hdmi->cec_notifier,
466		- hdmi->hpd_state,
467		- ktime_get());
468		- }
469		-#endif
	428	+ if (change && hdmi->cec_adap &&
	429	+ hdmi->cec_adap->devnode.registered)
	430	+ cec_queue_pin_hpd_event(hdmi->cec_adap,
	431	+ hdmi->hpd_state,
	432	+ ktime_get());
	433	+ drm_bridge_hpd_notify(&hdmi->bridge, status);
470	434	}
471	435	}
472	436
..	..	@@ -544,6 +508,13 @@
544	508
545	509	static void dw_hdmi_i2c_init(struct dw_hdmi *hdmi)
546	510	{
	511	+ hdmi_writeb(hdmi, HDMI_PHY_I2CM_INT_ADDR_DONE_POL,
	512	+ HDMI_PHY_I2CM_INT_ADDR);
	513	+
	514	+ hdmi_writeb(hdmi, HDMI_PHY_I2CM_CTLINT_ADDR_NAC_POL \|
	515	+ HDMI_PHY_I2CM_CTLINT_ADDR_ARBITRATION_POL,
	516	+ HDMI_PHY_I2CM_CTLINT_ADDR);
	517	+
547	518	/* Software reset */
548	519	hdmi_writeb(hdmi, 0x00, HDMI_I2CM_SOFTRSTZ);
549	520
..	..	@@ -570,11 +541,82 @@
570	541	dw_hdmi_i2c_set_divs(hdmi);
571	542	}
572	543
	544	+static bool dw_hdmi_i2c_unwedge(struct dw_hdmi *hdmi)
	545	+{
	546	+ /* If no unwedge state then give up */
	547	+ if (!hdmi->unwedge_state)
	548	+ return false;
	549	+
	550	+ dev_info(hdmi->dev, "Attempting to unwedge stuck i2c bus\n");
	551	+
	552	+ /*
	553	+ * This is a huge hack to workaround a problem where the dw_hdmi i2c
	554	+ * bus could sometimes get wedged. Once wedged there doesn't appear
	555	+ * to be any way to unwedge it (including the HDMI_I2CM_SOFTRSTZ)
	556	+ * other than pulsing the SDA line.
	557	+ *
	558	+ * We appear to be able to pulse the SDA line (in the eyes of dw_hdmi)
	559	+ * by:
	560	+ * 1. Remux the pin as a GPIO output, driven low.
	561	+ * 2. Wait a little while. 1 ms seems to work, but we'll do 10.
	562	+ * 3. Immediately jump to remux the pin as dw_hdmi i2c again.
	563	+ *
	564	+ * At the moment of remuxing, the line will still be low due to its
	565	+ * recent stint as an output, but then it will be pulled high by the
	566	+ * (presumed) external pullup. dw_hdmi seems to see this as a rising
	567	+ * edge and that seems to get it out of its jam.
	568	+ *
	569	+ * This wedging was only ever seen on one TV, and only on one of
	570	+ * its HDMI ports. It happened when the TV was powered on while the
	571	+ * device was plugged in. A scope trace shows the TV bringing both SDA
	572	+ * and SCL low, then bringing them both back up at roughly the same
	573	+ * time. Presumably this confuses dw_hdmi because it saw activity but
	574	+ * no real STOP (maybe it thinks there's another master on the bus?).
	575	+ * Giving it a clean rising edge of SDA while SCL is already high
	576	+ * presumably makes dw_hdmi see a STOP which seems to bring dw_hdmi out
	577	+ * of its stupor.
	578	+ *
	579	+ * Note that after coming back alive, transfers seem to immediately
	580	+ * resume, so if we unwedge due to a timeout we should wait a little
	581	+ * longer for our transfer to finish, since it might have just started
	582	+ * now.
	583	+ */
	584	+ pinctrl_select_state(hdmi->pinctrl, hdmi->unwedge_state);
	585	+ msleep(10);
	586	+ pinctrl_select_state(hdmi->pinctrl, hdmi->default_state);
	587	+
	588	+ return true;
	589	+}
	590	+
	591	+static int dw_hdmi_i2c_wait(struct dw_hdmi *hdmi)
	592	+{
	593	+ struct dw_hdmi_i2c *i2c = hdmi->i2c;
	594	+ int stat;
	595	+
	596	+ stat = wait_for_completion_timeout(&i2c->cmp, HZ / 10);
	597	+ if (!stat) {
	598	+ /* If we can't unwedge, return timeout */
	599	+ if (!dw_hdmi_i2c_unwedge(hdmi))
	600	+ return -EAGAIN;
	601	+
	602	+ /* We tried to unwedge; give it another chance */
	603	+ stat = wait_for_completion_timeout(&i2c->cmp, HZ / 10);
	604	+ if (!stat)
	605	+ return -EAGAIN;
	606	+ }
	607	+
	608	+ /* Check for error condition on the bus */
	609	+ if (i2c->stat & HDMI_IH_I2CM_STAT0_ERROR)
	610	+ return -EIO;
	611	+
	612	+ return 0;
	613	+}
	614	+
573	615	static int dw_hdmi_i2c_read(struct dw_hdmi *hdmi,
574	616	unsigned char *buf, unsigned int length)
575	617	{
576	618	struct dw_hdmi_i2c *i2c = hdmi->i2c;
577		- int stat, retry, i;
	619	+ int ret, retry, i;
578	620	bool read_edid = false;
579	621
580	622	if (!i2c->is_regaddr) {
..	..	@@ -608,7 +650,7 @@
608	650	hdmi->plat_data->set_ddc_io(data, false);
609	651	return -EPERM;
610	652	}
611		- reinit_completion(&i2c->cmp);
	653	+
612	654	if (i2c->is_segment) {
613	655	if (read_edid)
614	656	hdmi_writeb(hdmi, HDMI_I2CM_OPERATION_READ8_EXT,
..	..	@@ -624,17 +666,16 @@
624	666	hdmi_writeb(hdmi, HDMI_I2CM_OPERATION_READ,
625	667	HDMI_I2CM_OPERATION);
626	668	}
627		- stat = wait_for_completion_timeout(&i2c->cmp, HZ / 10);
628		- if (!stat) {
	669	+
	670	+ ret = dw_hdmi_i2c_wait(hdmi);
	671	+ if (ret == -EAGAIN) {
629	672	dev_dbg(hdmi->dev, "ddc read time out\n");
630	673	hdmi_writeb(hdmi, 0, HDMI_I2CM_SOFTRSTZ);
631	674	hdmi_writeb(hdmi, HDMI_I2CM_OPERATION_BUS_CLEAR,
632	675	HDMI_I2CM_OPERATION);
633	676	retry -= 10;
634	677	continue;
635		- }
636		- /* Check for error condition on the bus */
637		- if (i2c->stat & HDMI_IH_I2CM_STAT0_ERROR) {
	678	+ } else if (ret == -EIO) {
638	679	dev_dbg(hdmi->dev, "ddc read err\n");
639	680	hdmi_writeb(hdmi, 0, HDMI_I2CM_SOFTRSTZ);
640	681	hdmi_writeb(hdmi, HDMI_I2CM_OPERATION_BUS_CLEAR,
..	..	@@ -667,7 +708,7 @@
667	708	unsigned char *buf, unsigned int length)
668	709	{
669	710	struct dw_hdmi_i2c *i2c = hdmi->i2c;
670		- int stat, retry;
	711	+ int ret, retry;
671	712
672	713	if (!i2c->is_regaddr) {
673	714	/* Use the first write byte as register address */
..	..	@@ -692,22 +733,20 @@
692	733	hdmi->plat_data->set_ddc_io(data, false);
693	734	return -EPERM;
694	735	}
	736	+
695	737	reinit_completion(&i2c->cmp);
696	738	hdmi_writeb(hdmi, HDMI_I2CM_OPERATION_WRITE,
697	739	HDMI_I2CM_OPERATION);
698	740
699		- stat = wait_for_completion_timeout(&i2c->cmp, HZ / 10);
700		- if (!stat) {
	741	+ ret = dw_hdmi_i2c_wait(hdmi);
	742	+ if (ret == -EAGAIN) {
701	743	dev_dbg(hdmi->dev, "ddc write time out\n");
702	744	hdmi_writeb(hdmi, 0, HDMI_I2CM_SOFTRSTZ);
703	745	hdmi_writeb(hdmi, HDMI_I2CM_OPERATION_BUS_CLEAR,
704	746	HDMI_I2CM_OPERATION);
705	747	retry -= 10;
706	748	continue;
707		- }
708		-
709		- /* Check for error condition on the bus */
710		- if (i2c->stat & HDMI_IH_I2CM_STAT0_ERROR) {
	749	+ } else if (ret == -EIO) {
711	750	dev_dbg(hdmi->dev, "ddc write err\n");
712	751	hdmi_writeb(hdmi, 0, HDMI_I2CM_SOFTRSTZ);
713	752	hdmi_writeb(hdmi, HDMI_I2CM_OPERATION_BUS_CLEAR,
..	..	@@ -866,8 +905,14 @@
866	905	/* nshift factor = 0 */
867	906	hdmi_modb(hdmi, 0, HDMI_AUD_CTS3_N_SHIFT_MASK, HDMI_AUD_CTS3);
868	907
869		- hdmi_writeb(hdmi, ((cts >> 16) & HDMI_AUD_CTS3_AUDCTS19_16_MASK) \|
870		- HDMI_AUD_CTS3_CTS_MANUAL, HDMI_AUD_CTS3);
	908	+ /* Use automatic CTS generation mode when CTS is not set */
	909	+ if (cts)
	910	+ hdmi_writeb(hdmi, ((cts >> 16) &
	911	+ HDMI_AUD_CTS3_AUDCTS19_16_MASK) \|
	912	+ HDMI_AUD_CTS3_CTS_MANUAL,
	913	+ HDMI_AUD_CTS3);
	914	+ else
	915	+ hdmi_writeb(hdmi, 0, HDMI_AUD_CTS3);
871	916	hdmi_writeb(hdmi, (cts >> 8) & 0xff, HDMI_AUD_CTS2);
872	917	hdmi_writeb(hdmi, cts & 0xff, HDMI_AUD_CTS1);
873	918
..	..	@@ -989,29 +1034,58 @@
989	1034	return hdmi_compute_n(hdmi, pixel_clk, sample_rate);
990	1035	}
991	1036
	1037	+/*
	1038	+ * When transmitting IEC60958 linear PCM audio, these registers allow to
	1039	+ * configure the channel status information of all the channel status
	1040	+ * bits in the IEC60958 frame. For the moment this configuration is only
	1041	+ * used when the I2S audio interface, General Purpose Audio (GPA),
	1042	+ * or AHB audio DMA (AHBAUDDMA) interface is active
	1043	+ * (for S/PDIF interface this information comes from the stream).
	1044	+ */
	1045	+void dw_hdmi_set_channel_status(struct dw_hdmi *hdmi,
	1046	+ u8 *channel_status)
	1047	+{
	1048	+ /*
	1049	+ * Set channel status register for frequency and word length.
	1050	+ * Use default values for other registers.
	1051	+ */
	1052	+ hdmi_writeb(hdmi, channel_status[3], HDMI_FC_AUDSCHNLS7);
	1053	+ hdmi_writeb(hdmi, channel_status[4], HDMI_FC_AUDSCHNLS8);
	1054	+}
	1055	+EXPORT_SYMBOL_GPL(dw_hdmi_set_channel_status);
	1056	+
992	1057	static void hdmi_set_clk_regenerator(struct dw_hdmi *hdmi,
993	1058	unsigned long pixel_clk, unsigned int sample_rate)
994	1059	{
995	1060	unsigned long ftdms = pixel_clk;
996	1061	unsigned int n, cts;
	1062	+ u8 config3;
997	1063	u64 tmp;
998	1064
999	1065	n = hdmi_find_n(hdmi, pixel_clk, sample_rate);
1000	1066
1001		- /*
1002		- * Compute the CTS value from the N value. Note that CTS and N
1003		- * can be up to 20 bits in total, so we need 64-bit math. Also
1004		- * note that our TDMS clock is not fully accurate; it is accurate
1005		- * to kHz. This can introduce an unnecessary remainder in the
1006		- * calculation below, so we don't try to warn about that.
1007		- */
1008		- tmp = (u64)ftdms * n;
1009		- do_div(tmp, 128 * sample_rate);
1010		- cts = tmp;
	1067	+ config3 = hdmi_readb(hdmi, HDMI_CONFIG3_ID);
1011	1068
1012		- dev_dbg(hdmi->dev, "%s: fs=%uHz ftdms=%lu.%03luMHz N=%d cts=%d\n",
1013		- __func__, sample_rate, ftdms / 1000000, (ftdms / 1000) % 1000,
1014		- n, cts);
	1069	+ /* Only compute CTS when using internal AHB audio */
	1070	+ if (config3 & HDMI_CONFIG3_AHBAUDDMA) {
	1071	+ /*
	1072	+ * Compute the CTS value from the N value. Note that CTS and N
	1073	+ * can be up to 20 bits in total, so we need 64-bit math. Also
	1074	+ * note that our TDMS clock is not fully accurate; it is
	1075	+ * accurate to kHz. This can introduce an unnecessary remainder
	1076	+ * in the calculation below, so we don't try to warn about that.
	1077	+ */
	1078	+ tmp = (u64)ftdms * n;
	1079	+ do_div(tmp, 128 * sample_rate);
	1080	+ cts = tmp;
	1081	+
	1082	+ dev_dbg(hdmi->dev, "%s: fs=%uHz ftdms=%lu.%03luMHz N=%d cts=%d\n",
	1083	+ __func__, sample_rate,
	1084	+ ftdms / 1000000, (ftdms / 1000) % 1000,
	1085	+ n, cts);
	1086	+ } else {
	1087	+ cts = 0;
	1088	+ }
1015	1089
1016	1090	spin_lock_irq(&hdmi->audio_lock);
1017	1091	hdmi->audio_n = n;
..	..	@@ -1045,6 +1119,42 @@
1045	1119	}
1046	1120	EXPORT_SYMBOL_GPL(dw_hdmi_set_sample_rate);
1047	1121
	1122	+void dw_hdmi_set_channel_count(struct dw_hdmi *hdmi, unsigned int cnt)
	1123	+{
	1124	+ u8 layout;
	1125	+
	1126	+ mutex_lock(&hdmi->audio_mutex);
	1127	+
	1128	+ /*
	1129	+ * For >2 channel PCM audio, we need to select layout 1
	1130	+ * and set an appropriate channel map.
	1131	+ */
	1132	+ if (cnt > 2)
	1133	+ layout = HDMI_FC_AUDSCONF_AUD_PACKET_LAYOUT_LAYOUT1;
	1134	+ else
	1135	+ layout = HDMI_FC_AUDSCONF_AUD_PACKET_LAYOUT_LAYOUT0;
	1136	+
	1137	+ hdmi_modb(hdmi, layout, HDMI_FC_AUDSCONF_AUD_PACKET_LAYOUT_MASK,
	1138	+ HDMI_FC_AUDSCONF);
	1139	+
	1140	+ /* Set the audio infoframes channel count */
	1141	+ hdmi_modb(hdmi, (cnt - 1) << HDMI_FC_AUDICONF0_CC_OFFSET,
	1142	+ HDMI_FC_AUDICONF0_CC_MASK, HDMI_FC_AUDICONF0);
	1143	+
	1144	+ mutex_unlock(&hdmi->audio_mutex);
	1145	+}
	1146	+EXPORT_SYMBOL_GPL(dw_hdmi_set_channel_count);
	1147	+
	1148	+void dw_hdmi_set_channel_allocation(struct dw_hdmi *hdmi, unsigned int ca)
	1149	+{
	1150	+ mutex_lock(&hdmi->audio_mutex);
	1151	+
	1152	+ hdmi_writeb(hdmi, ca, HDMI_FC_AUDICONF2);
	1153	+
	1154	+ mutex_unlock(&hdmi->audio_mutex);
	1155	+}
	1156	+EXPORT_SYMBOL_GPL(dw_hdmi_set_channel_allocation);
	1157	+
1048	1158	static void hdmi_enable_audio_clk(struct dw_hdmi *hdmi, bool enable)
1049	1159	{
1050	1160	if (enable)
..	..	@@ -1052,6 +1162,14 @@
1052	1162	else
1053	1163	hdmi->mc_clkdis \|= HDMI_MC_CLKDIS_AUDCLK_DISABLE;
1054	1164	hdmi_writeb(hdmi, hdmi->mc_clkdis, HDMI_MC_CLKDIS);
	1165	+}
	1166	+
	1167	+static u8 hdmi_audio_get_eld(struct dw_hdmi hdmi)
	1168	+{
	1169	+ if (!hdmi->curr_conn)
	1170	+ return NULL;
	1171	+
	1172	+ return hdmi->curr_conn->eld;
1055	1173	}
1056	1174
1057	1175	static void dw_hdmi_ahb_audio_enable(struct dw_hdmi *hdmi)
..	..	@@ -1262,25 +1380,14 @@
1262	1380
1263	1381	static int is_color_space_conversion(struct dw_hdmi *hdmi)
1264	1382	{
1265		- const struct drm_display_mode mode = hdmi->previous_mode;
1266		- bool is_cea_default;
	1383	+ struct hdmi_data_info *hdmi_data = &hdmi->hdmi_data;
	1384	+ bool is_input_rgb, is_output_rgb;
1267	1385
1268		- is_cea_default = (drm_match_cea_mode(&mode) > 1) &&
1269		- (hdmi->hdmi_data.quant_range ==
1270		- HDMI_QUANTIZATION_RANGE_DEFAULT);
	1386	+ is_input_rgb = hdmi_bus_fmt_is_rgb(hdmi_data->enc_in_bus_format);
	1387	+ is_output_rgb = hdmi_bus_fmt_is_rgb(hdmi_data->enc_out_bus_format);
1271	1388
1272		- /*
1273		- * When output is rgb limited range or default range with
1274		- * cea mode, csc should be enabled.
1275		- */
1276		- if (hdmi->hdmi_data.enc_in_bus_format !=
1277		- hdmi->hdmi_data.enc_out_bus_format \|\|
1278		- ((hdmi->hdmi_data.quant_range == HDMI_QUANTIZATION_RANGE_LIMITED \|\|
1279		- is_cea_default) &&
1280		- hdmi_bus_fmt_is_rgb(hdmi->hdmi_data.enc_in_bus_format)))
1281		- return 1;
1282		-
1283		- return 0;
	1389	+ return (is_input_rgb != is_output_rgb) \|\|
	1390	+ (is_input_rgb && is_output_rgb && hdmi_data->rgb_limited_range);
1284	1391	}
1285	1392
1286	1393	static int is_color_space_decimation(struct dw_hdmi *hdmi)
..	..	@@ -1307,43 +1414,46 @@
1307	1414	return 0;
1308	1415	}
1309	1416
	1417	+static bool is_csc_needed(struct dw_hdmi *hdmi)
	1418	+{
	1419	+ return is_color_space_conversion(hdmi) \|\|
	1420	+ is_color_space_decimation(hdmi) \|\|
	1421	+ is_color_space_interpolation(hdmi);
	1422	+}
	1423	+
	1424	+static bool is_rgb_full_to_limited_needed(struct dw_hdmi *hdmi)
	1425	+{
	1426	+ if (hdmi->hdmi_data.quant_range == HDMI_QUANTIZATION_RANGE_LIMITED \|\|
	1427	+ (!hdmi->hdmi_data.quant_range && hdmi->hdmi_data.rgb_limited_range))
	1428	+ return true;
	1429	+
	1430	+ return false;
	1431	+}
	1432	+
1310	1433	static void dw_hdmi_update_csc_coeffs(struct dw_hdmi *hdmi)
1311	1434	{
1312	1435	const u16 (*csc_coeff)[3][4] = &csc_coeff_default;
	1436	+ bool is_input_rgb, is_output_rgb;
1313	1437	unsigned i;
1314	1438	u32 csc_scale = 1;
1315		- int enc_out_rgb, enc_in_rgb;
1316		- int color_depth;
1317	1439
1318		- enc_out_rgb = hdmi_bus_fmt_is_rgb(hdmi->hdmi_data.enc_out_bus_format);
1319		- enc_in_rgb = hdmi_bus_fmt_is_rgb(hdmi->hdmi_data.enc_in_bus_format);
1320		- color_depth = hdmi_bus_fmt_color_depth(hdmi->hdmi_data.enc_out_bus_format);
	1440	+ is_input_rgb = hdmi_bus_fmt_is_rgb(hdmi->hdmi_data.enc_in_bus_format);
	1441	+ is_output_rgb = hdmi_bus_fmt_is_rgb(hdmi->hdmi_data.enc_out_bus_format);
1321	1442
1322		- if (is_color_space_conversion(hdmi)) {
1323		- if (enc_out_rgb && enc_in_rgb) {
1324		- csc_coeff = &csc_coeff_full_to_limited;
1325		- csc_scale = 0;
1326		- } else if (enc_out_rgb) {
1327		- if (hdmi->hdmi_data.enc_out_encoding ==
1328		- V4L2_YCBCR_ENC_601)
1329		- csc_coeff = &csc_coeff_rgb_out_eitu601;
1330		- else
1331		- csc_coeff = &csc_coeff_rgb_out_eitu709;
1332		- } else if (enc_in_rgb) {
1333		- if (hdmi->hdmi_data.enc_out_encoding ==
1334		- V4L2_YCBCR_ENC_601) {
1335		- if (color_depth == 10)
1336		- csc_coeff = &csc_coeff_rgb_in_eitu601_10bit_limited;
1337		- else
1338		- csc_coeff = &csc_coeff_rgb_in_eitu601_limited;
1339		- } else {
1340		- if (color_depth == 10)
1341		- csc_coeff = &csc_coeff_rgb_in_eitu709_10bit_limited;
1342		- else
1343		- csc_coeff = &csc_coeff_rgb_in_eitu709_limited;
1344		- }
1345		- csc_scale = 0;
1346		- }
	1443	+ if (!is_input_rgb && is_output_rgb) {
	1444	+ if (hdmi->hdmi_data.enc_out_encoding == V4L2_YCBCR_ENC_601)
	1445	+ csc_coeff = &csc_coeff_rgb_out_eitu601;
	1446	+ else
	1447	+ csc_coeff = &csc_coeff_rgb_out_eitu709;
	1448	+ } else if (is_input_rgb && !is_output_rgb) {
	1449	+ if (hdmi->hdmi_data.enc_out_encoding == V4L2_YCBCR_ENC_601)
	1450	+ csc_coeff = &csc_coeff_rgb_in_eitu601;
	1451	+ else
	1452	+ csc_coeff = &csc_coeff_rgb_in_eitu709;
	1453	+ csc_scale = 0;
	1454	+ } else if (is_input_rgb && is_output_rgb &&
	1455	+ is_rgb_full_to_limited_needed(hdmi)) {
	1456	+ csc_coeff = &csc_coeff_rgb_full_to_rgb_limited;
1347	1457	}
1348	1458
1349	1459	/* The CSC registers are sequential, alternating MSB then LSB */
..	..	@@ -1551,30 +1661,16 @@
1551	1661	}
1552	1662	EXPORT_SYMBOL_GPL(dw_hdmi_phy_i2c_write);
1553	1663
1554		-static int hdmi_phy_i2c_read(struct dw_hdmi *hdmi, unsigned char addr)
1555		-{
1556		- int val;
1557		-
1558		- hdmi_writeb(hdmi, 0xFF, HDMI_IH_I2CMPHY_STAT0);
1559		- hdmi_writeb(hdmi, addr, HDMI_PHY_I2CM_ADDRESS_ADDR);
1560		- hdmi_writeb(hdmi, 0, HDMI_PHY_I2CM_DATAI_1_ADDR);
1561		- hdmi_writeb(hdmi, 0, HDMI_PHY_I2CM_DATAI_0_ADDR);
1562		- hdmi_writeb(hdmi, HDMI_PHY_I2CM_OPERATION_ADDR_READ,
1563		- HDMI_PHY_I2CM_OPERATION_ADDR);
1564		- hdmi_phy_wait_i2c_done(hdmi, 1000);
1565		- val = hdmi_readb(hdmi, HDMI_PHY_I2CM_DATAI_1_ADDR);
1566		- val = (val & 0xff) << 8;
1567		- val += hdmi_readb(hdmi, HDMI_PHY_I2CM_DATAI_0_ADDR) & 0xff;
1568		- return val;
1569		-}
1570		-
1571	1664	/* Filter out invalid setups to avoid configuring SCDC and scrambling */
1572		-static bool dw_hdmi_support_scdc(struct dw_hdmi *hdmi)
	1665	+static bool dw_hdmi_support_scdc(struct dw_hdmi *hdmi,
	1666	+ const struct drm_display_info *display)
1573	1667	{
1574		- struct drm_display_info *display = &hdmi->connector.display_info;
1575		-
1576	1668	/* Completely disable SCDC support for older controllers */
1577	1669	if (hdmi->version < 0x200a)
	1670	+ return false;
	1671	+
	1672	+ /* Disable if no DDC bus */
	1673	+ if (!hdmi->ddc)
1578	1674	return false;
1579	1675
1580	1676	/* Disable if SCDC is not supported, or if an HF-VSDB block is absent */
..	..	@@ -1593,6 +1689,23 @@
1593	1689	return true;
1594	1690	}
1595	1691
	1692	+static int hdmi_phy_i2c_read(struct dw_hdmi *hdmi, unsigned char addr)
	1693	+{
	1694	+ int val;
	1695	+
	1696	+ hdmi_writeb(hdmi, 0xFF, HDMI_IH_I2CMPHY_STAT0);
	1697	+ hdmi_writeb(hdmi, addr, HDMI_PHY_I2CM_ADDRESS_ADDR);
	1698	+ hdmi_writeb(hdmi, 0, HDMI_PHY_I2CM_DATAI_1_ADDR);
	1699	+ hdmi_writeb(hdmi, 0, HDMI_PHY_I2CM_DATAI_0_ADDR);
	1700	+ hdmi_writeb(hdmi, HDMI_PHY_I2CM_OPERATION_ADDR_READ,
	1701	+ HDMI_PHY_I2CM_OPERATION_ADDR);
	1702	+ hdmi_phy_wait_i2c_done(hdmi, 1000);
	1703	+ val = hdmi_readb(hdmi, HDMI_PHY_I2CM_DATAI_1_ADDR);
	1704	+ val = (val & 0xff) << 8;
	1705	+ val += hdmi_readb(hdmi, HDMI_PHY_I2CM_DATAI_0_ADDR) & 0xff;
	1706	+ return val;
	1707	+}
	1708	+
1596	1709	/*
1597	1710	* HDMI2.0 Specifies the following procedure for High TMDS Bit Rates:
1598	1711	* - The Source shall suspend transmission of the TMDS clock and data
..	..	@@ -1606,12 +1719,13 @@
1606	1719	* helper should called right before enabling the TMDS Clock and Data in
1607	1720	* the PHY configuration callback.
1608	1721	*/
1609		-void dw_hdmi_set_high_tmds_clock_ratio(struct dw_hdmi *hdmi)
	1722	+void dw_hdmi_set_high_tmds_clock_ratio(struct dw_hdmi *hdmi,
	1723	+ const struct drm_display_info *display)
1610	1724	{
1611	1725	unsigned long mtmdsclock = hdmi->hdmi_data.video_mode.mtmdsclock;
1612	1726
1613	1727	/* Control for TMDS Bit Period/TMDS Clock-Period Ratio */
1614		- if (dw_hdmi_support_scdc(hdmi)) {
	1728	+ if (dw_hdmi_support_scdc(hdmi, display)) {
1615	1729	if (mtmdsclock > HDMI14_MAX_TMDSCLK)
1616	1730	drm_scdc_set_high_tmds_clock_ratio(hdmi->ddc, 1);
1617	1731	else
..	..	@@ -1824,7 +1938,8 @@
1824	1938	return 0;
1825	1939	}
1826	1940
1827		-static int hdmi_phy_configure(struct dw_hdmi *hdmi)
	1941	+static int hdmi_phy_configure(struct dw_hdmi *hdmi,
	1942	+ const struct drm_display_info *display)
1828	1943	{
1829	1944	const struct dw_hdmi_phy_data *phy = hdmi->phy.data;
1830	1945	const struct dw_hdmi_plat_data *pdata = hdmi->plat_data;
..	..	@@ -1834,7 +1949,7 @@
1834	1949
1835	1950	dw_hdmi_phy_power_off(hdmi);
1836	1951
1837		- dw_hdmi_set_high_tmds_clock_ratio(hdmi);
	1952	+ dw_hdmi_set_high_tmds_clock_ratio(hdmi, display);
1838	1953
1839	1954	/* Leave low power consumption mode by asserting SVSRET. */
1840	1955	if (phy->has_svsret)
..	..	@@ -1848,7 +1963,7 @@
1848	1963
1849	1964	/* Write to the PHY as configured by the platform */
1850	1965	if (pdata->configure_phy)
1851		- ret = pdata->configure_phy(hdmi, pdata, mpixelclock);
	1966	+ ret = pdata->configure_phy(hdmi, pdata->priv_data, mpixelclock);
1852	1967	else
1853	1968	ret = phy->configure(hdmi, pdata, mpixelclock);
1854	1969	if (ret) {
..	..	@@ -1865,7 +1980,8 @@
1865	1980	}
1866	1981
1867	1982	static int dw_hdmi_phy_init(struct dw_hdmi hdmi, void data,
1868		- struct drm_display_mode *mode)
	1983	+ const struct drm_display_info *display,
	1984	+ const struct drm_display_mode *mode)
1869	1985	{
1870	1986	int i, ret;
1871	1987
..	..	@@ -1874,7 +1990,7 @@
1874	1990	dw_hdmi_phy_sel_data_en_pol(hdmi, 1);
1875	1991	dw_hdmi_phy_sel_interface_control(hdmi, 0);
1876	1992
1877		- ret = hdmi_phy_configure(hdmi);
	1993	+ ret = hdmi_phy_configure(hdmi, display);
1878	1994	if (ret)
1879	1995	return ret;
1880	1996	}
..	..	@@ -1977,23 +2093,35 @@
1977	2093	hdmi->hdcp->hdcp_start(hdmi->hdcp);
1978	2094	}
1979	2095
1980		-static void hdmi_config_AVI(struct dw_hdmi hdmi, struct drm_display_mode mode)
	2096	+static void hdmi_config_AVI(struct dw_hdmi *hdmi,
	2097	+ const struct drm_connector *connector,
	2098	+ const struct drm_display_mode *mode)
1981	2099	{
1982	2100	struct hdmi_avi_infoframe frame;
1983	2101	u8 val;
1984		- bool is_hdmi2 = false;
1985		- enum hdmi_quantization_range rgb_quant_range =
1986		- hdmi->hdmi_data.quant_range;
	2102	+ bool is_hdmi2;
	2103	+ const struct drm_display_info *info = &connector->display_info;
1987	2104
1988		- if (hdmi_bus_fmt_is_yuv420(hdmi->hdmi_data.enc_out_bus_format) \|\|
1989		- hdmi->connector.display_info.hdmi.scdc.supported)
1990		- is_hdmi2 = true;
	2105	+ is_hdmi2 = info->hdmi.scdc.supported \|\| (info->color_formats & DRM_COLOR_FORMAT_YCRCB420);
	2106	+
1991	2107	/* Initialise info frame from DRM mode */
1992		- drm_hdmi_avi_infoframe_from_display_mode(&frame, mode, is_hdmi2);
	2108	+ drm_hdmi_avi_infoframe_from_display_mode(&frame, connector, mode);
1993	2109
1994		- drm_hdmi_avi_infoframe_quant_range(&frame, mode, rgb_quant_range,
1995		- hdmi->rgb_quant_range_selectable \|\| is_hdmi2,
1996		- is_hdmi2);
	2110	+ if (hdmi_bus_fmt_is_rgb(hdmi->hdmi_data.enc_out_bus_format)) {
	2111	+ /* default range */
	2112	+ if (!hdmi->hdmi_data.quant_range)
	2113	+ drm_hdmi_avi_infoframe_quant_range(&frame, connector, mode,
	2114	+ hdmi->hdmi_data.rgb_limited_range ?
	2115	+ HDMI_QUANTIZATION_RANGE_LIMITED :
	2116	+ HDMI_QUANTIZATION_RANGE_FULL);
	2117	+ else
	2118	+ drm_hdmi_avi_infoframe_quant_range(&frame, connector, mode,
	2119	+ hdmi->hdmi_data.quant_range);
	2120	+ } else {
	2121	+ frame.quantization_range = HDMI_QUANTIZATION_RANGE_DEFAULT;
	2122	+ frame.ycc_quantization_range =
	2123	+ HDMI_YCC_QUANTIZATION_RANGE_LIMITED;
	2124	+ }
1997	2125
1998	2126	if (hdmi_bus_fmt_is_yuv444(hdmi->hdmi_data.enc_out_bus_format))
1999	2127	frame.colorspace = HDMI_COLORSPACE_YUV444;
..	..	@@ -2029,8 +2157,8 @@
2029	2157	else
2030	2158	frame.colorimetry = HDMI_COLORIMETRY_ITU_709;
2031	2159	frame.extended_colorimetry =
2032		- HDMI_EXTENDED_COLORIMETRY_BT2020;
2033		- break;
	2160	+ HDMI_EXTENDED_COLORIMETRY_BT2020;
	2161	+ break;
2034	2162	default: /* Carries no data */
2035	2163	frame.colorimetry = HDMI_COLORIMETRY_ITU_601;
2036	2164	frame.extended_colorimetry =
..	..	@@ -2054,8 +2182,6 @@
2054	2182	else
2055	2183	frame.ycc_quantization_range = HDMI_YCC_QUANTIZATION_RANGE_LIMITED;
2056	2184	}
2057		-
2058		- frame.scan_mode = HDMI_SCAN_MODE_NONE;
2059	2185
2060	2186	/*
2061	2187	* The Designware IP uses a different byte format from standard
..	..	@@ -2128,7 +2254,8 @@
2128	2254	}
2129	2255
2130	2256	static void hdmi_config_vendor_specific_infoframe(struct dw_hdmi *hdmi,
2131		- struct drm_display_mode *mode)
	2257	+ const struct drm_connector *connector,
	2258	+ const struct drm_display_mode *mode)
2132	2259	{
2133	2260	struct hdmi_vendor_infoframe frame;
2134	2261	u8 buffer[10];
..	..	@@ -2189,6 +2316,77 @@
2189	2316	HDMI_FC_DATAUTO0_VSD_MASK);
2190	2317	}
2191	2318
	2319	+static void hdmi_config_drm_infoframe(struct dw_hdmi *hdmi,
	2320	+ const struct drm_connector *connector)
	2321	+{
	2322	+ const struct drm_connector_state *conn_state = connector->state;
	2323	+ struct hdr_output_metadata *hdr_metadata;
	2324	+ struct hdmi_drm_infoframe frame;
	2325	+ u8 buffer[30];
	2326	+ ssize_t err;
	2327	+ int i;
	2328	+
	2329	+ /* Dynamic Range and Mastering Infoframe is introduced in v2.11a. */
	2330	+ if (hdmi->version < 0x211a) {
	2331	+ DRM_ERROR("Not support DRM Infoframe\n");
	2332	+ return;
	2333	+ }
	2334	+
	2335	+ if (!hdmi->plat_data->use_drm_infoframe)
	2336	+ return;
	2337	+
	2338	+ hdmi_modb(hdmi, HDMI_FC_PACKET_TX_EN_DRM_DISABLE,
	2339	+ HDMI_FC_PACKET_TX_EN_DRM_MASK, HDMI_FC_PACKET_TX_EN);
	2340	+
	2341	+ if (!hdmi->connector.hdr_sink_metadata.hdmi_type1.eotf) {
	2342	+ DRM_DEBUG("No need to set HDR metadata in infoframe\n");
	2343	+ return;
	2344	+ }
	2345	+
	2346	+ if (!conn_state->hdr_output_metadata) {
	2347	+ DRM_DEBUG("source metadata not set yet\n");
	2348	+ return;
	2349	+ }
	2350	+
	2351	+ hdr_metadata = (struct hdr_output_metadata *)
	2352	+ conn_state->hdr_output_metadata->data;
	2353	+
	2354	+ if (!(hdmi->connector.hdr_sink_metadata.hdmi_type1.eotf &
	2355	+ BIT(hdr_metadata->hdmi_metadata_type1.eotf))) {
	2356	+ DRM_ERROR("Not support EOTF %d\n",
	2357	+ hdr_metadata->hdmi_metadata_type1.eotf);
	2358	+ return;
	2359	+ }
	2360	+
	2361	+ err = drm_hdmi_infoframe_set_hdr_metadata(&frame, conn_state);
	2362	+ if (err < 0)
	2363	+ return;
	2364	+
	2365	+ err = hdmi_drm_infoframe_pack(&frame, buffer, sizeof(buffer));
	2366	+ if (err < 0) {
	2367	+ dev_err(hdmi->dev, "Failed to pack drm infoframe: %zd\n", err);
	2368	+ return;
	2369	+ }
	2370	+
	2371	+ hdmi_writeb(hdmi, frame.version, HDMI_FC_DRM_HB0);
	2372	+ hdmi_writeb(hdmi, frame.length, HDMI_FC_DRM_HB1);
	2373	+
	2374	+ for (i = 0; i < frame.length; i++)
	2375	+ hdmi_writeb(hdmi, buffer[4 + i], HDMI_FC_DRM_PB0 + i);
	2376	+
	2377	+ hdmi_writeb(hdmi, 1, HDMI_FC_DRM_UP);
	2378	+ /*
	2379	+ * avi and hdr infoframe cannot be sent at the same time
	2380	+ * for compatibility with Huawei TV
	2381	+ */
	2382	+ msleep(300);
	2383	+ hdmi_modb(hdmi, HDMI_FC_PACKET_TX_EN_DRM_ENABLE,
	2384	+ HDMI_FC_PACKET_TX_EN_DRM_MASK, HDMI_FC_PACKET_TX_EN);
	2385	+
	2386	+ DRM_DEBUG("%s eotf %d end\n", __func__,
	2387	+ hdr_metadata->hdmi_metadata_type1.eotf);
	2388	+}
	2389	+
2192	2390	static unsigned int
2193	2391	hdmi_get_tmdsclock(struct dw_hdmi *hdmi, unsigned long mpixelclock)
2194	2392	{
..	..	@@ -2215,114 +2413,12 @@
2215	2413	return tmdsclock;
2216	2414	}
2217	2415
2218		-#define HDR_LSB(n) ((n) & 0xff)
2219		-#define HDR_MSB(n) (((n) & 0xff00) >> 8)
2220		-
2221		-/* Set Dynamic Range and Mastering Infoframe */
2222		-static void hdmi_config_hdr_infoframe(struct dw_hdmi *hdmi)
2223		-{
2224		- struct hdmi_drm_infoframe frame;
2225		- struct hdr_output_metadata *hdr_metadata;
2226		- struct drm_connector_state *conn_state = hdmi->connector.state;
2227		- int ret;
2228		-
2229		- /* Dynamic Range and Mastering Infoframe is introduced in v2.11a. */
2230		- if (hdmi->version < 0x211a) {
2231		- DRM_ERROR("Not support DRM Infoframe\n");
2232		- return;
2233		- }
2234		-
2235		- hdmi_modb(hdmi, HDMI_FC_PACKET_DRM_TX_DEN,
2236		- HDMI_FC_PACKET_DRM_TX_EN_MASK, HDMI_FC_PACKET_TX_EN);
2237		-
2238		- if (!hdmi->connector.hdr_sink_metadata.hdmi_type1.eotf) {
2239		- DRM_DEBUG("No need to set HDR metadata in infoframe\n");
2240		- return;
2241		- }
2242		-
2243		- if (!conn_state->hdr_output_metadata) {
2244		- DRM_DEBUG("source metadata not set yet\n");
2245		- return;
2246		- }
2247		-
2248		- hdr_metadata = (struct hdr_output_metadata *)
2249		- conn_state->hdr_output_metadata->data;
2250		-
2251		- if (!(hdmi->connector.hdr_sink_metadata.hdmi_type1.eotf &
2252		- BIT(hdr_metadata->hdmi_metadata_type1.eotf))) {
2253		- DRM_ERROR("Not support EOTF %d\n",
2254		- hdr_metadata->hdmi_metadata_type1.eotf);
2255		- return;
2256		- }
2257		-
2258		- ret = drm_hdmi_infoframe_set_hdr_metadata(&frame, conn_state);
2259		- if (ret < 0) {
2260		- DRM_ERROR("couldn't set HDR metadata in infoframe\n");
2261		- return;
2262		- }
2263		-
2264		- hdmi_writeb(hdmi, 1, HDMI_FC_DRM_HB0);
2265		- hdmi_writeb(hdmi, frame.length, HDMI_FC_DRM_HB1);
2266		- hdmi_writeb(hdmi, frame.eotf, HDMI_FC_DRM_PB0);
2267		- hdmi_writeb(hdmi, frame.metadata_type, HDMI_FC_DRM_PB1);
2268		- hdmi_writeb(hdmi, HDR_LSB(frame.display_primaries[0].x),
2269		- HDMI_FC_DRM_PB2);
2270		- hdmi_writeb(hdmi, HDR_MSB(frame.display_primaries[0].x),
2271		- HDMI_FC_DRM_PB3);
2272		- hdmi_writeb(hdmi, HDR_LSB(frame.display_primaries[0].y),
2273		- HDMI_FC_DRM_PB4);
2274		- hdmi_writeb(hdmi, HDR_MSB(frame.display_primaries[0].y),
2275		- HDMI_FC_DRM_PB5);
2276		- hdmi_writeb(hdmi, HDR_LSB(frame.display_primaries[1].x),
2277		- HDMI_FC_DRM_PB6);
2278		- hdmi_writeb(hdmi, HDR_MSB(frame.display_primaries[1].x),
2279		- HDMI_FC_DRM_PB7);
2280		- hdmi_writeb(hdmi, HDR_LSB(frame.display_primaries[1].y),
2281		- HDMI_FC_DRM_PB8);
2282		- hdmi_writeb(hdmi, HDR_MSB(frame.display_primaries[1].y),
2283		- HDMI_FC_DRM_PB9);
2284		- hdmi_writeb(hdmi, HDR_LSB(frame.display_primaries[2].x),
2285		- HDMI_FC_DRM_PB10);
2286		- hdmi_writeb(hdmi, HDR_MSB(frame.display_primaries[2].x),
2287		- HDMI_FC_DRM_PB11);
2288		- hdmi_writeb(hdmi, HDR_LSB(frame.display_primaries[2].y),
2289		- HDMI_FC_DRM_PB12);
2290		- hdmi_writeb(hdmi, HDR_MSB(frame.display_primaries[2].y),
2291		- HDMI_FC_DRM_PB13);
2292		- hdmi_writeb(hdmi, HDR_LSB(frame.white_point.x), HDMI_FC_DRM_PB14);
2293		- hdmi_writeb(hdmi, HDR_MSB(frame.white_point.x), HDMI_FC_DRM_PB15);
2294		- hdmi_writeb(hdmi, HDR_LSB(frame.white_point.y), HDMI_FC_DRM_PB16);
2295		- hdmi_writeb(hdmi, HDR_MSB(frame.white_point.y), HDMI_FC_DRM_PB17);
2296		- hdmi_writeb(hdmi, HDR_LSB(frame.max_display_mastering_luminance),
2297		- HDMI_FC_DRM_PB18);
2298		- hdmi_writeb(hdmi, HDR_MSB(frame.max_display_mastering_luminance),
2299		- HDMI_FC_DRM_PB19);
2300		- hdmi_writeb(hdmi, HDR_LSB(frame.min_display_mastering_luminance),
2301		- HDMI_FC_DRM_PB20);
2302		- hdmi_writeb(hdmi, HDR_MSB(frame.min_display_mastering_luminance),
2303		- HDMI_FC_DRM_PB21);
2304		- hdmi_writeb(hdmi, HDR_LSB(frame.max_cll), HDMI_FC_DRM_PB22);
2305		- hdmi_writeb(hdmi, HDR_MSB(frame.max_cll), HDMI_FC_DRM_PB23);
2306		- hdmi_writeb(hdmi, HDR_LSB(frame.max_fall), HDMI_FC_DRM_PB24);
2307		- hdmi_writeb(hdmi, HDR_MSB(frame.max_fall), HDMI_FC_DRM_PB25);
2308		- hdmi_writeb(hdmi, 1, HDMI_FC_DRM_UP);
2309		- /*
2310		- * avi and hdr infoframe cannot be sent at the same time
2311		- * for compatibility with Huawei TV
2312		- */
2313		- msleep(300);
2314		- hdmi_modb(hdmi, HDMI_FC_PACKET_DRM_TX_EN,
2315		- HDMI_FC_PACKET_DRM_TX_EN_MASK, HDMI_FC_PACKET_TX_EN);
2316		-
2317		- DRM_DEBUG("%s eotf %d end\n", __func__,
2318		- hdr_metadata->hdmi_metadata_type1.eotf);
2319		-}
2320		-
2321	2416	static void hdmi_av_composer(struct dw_hdmi *hdmi,
	2417	+ const struct drm_display_info *display,
2322	2418	const struct drm_display_mode *mode)
2323	2419	{
2324	2420	u8 inv_val, bytes;
2325		- struct drm_hdmi_info *hdmi_info = &hdmi->connector.display_info.hdmi;
	2421	+ const struct drm_hdmi_info *hdmi_info = &display->hdmi;
2326	2422	struct hdmi_vmode *vmode = &hdmi->hdmi_data.video_mode;
2327	2423	int hblank, vblank, h_de_hs, v_de_vs, hsync_len, vsync_len;
2328	2424	unsigned int vdisplay, hdisplay;
..	..	@@ -2338,6 +2434,7 @@
2338	2434	vmode->mtmdsclock = hdmi_get_tmdsclock(hdmi, vmode->mpixelclock);
2339	2435	if (hdmi_bus_fmt_is_yuv420(hdmi->hdmi_data.enc_out_bus_format))
2340	2436	vmode->mtmdsclock /= 2;
	2437	+ dev_dbg(hdmi->dev, "final tmdsclock = %d\n", vmode->mtmdsclock);
2341	2438
2342	2439	if (hdmi->update)
2343	2440	return;
..	..	@@ -2408,13 +2505,10 @@
2408	2505	vblank /= 2;
2409	2506	v_de_vs /= 2;
2410	2507	vsync_len /= 2;
2411		- } else if ((mode->flags & DRM_MODE_FLAG_3D_MASK) ==
2412		- DRM_MODE_FLAG_3D_FRAME_PACKING) {
2413		- vdisplay += mode->vtotal;
2414	2508	}
2415	2509
2416	2510	/* Scrambling Control */
2417		- if (dw_hdmi_support_scdc(hdmi)) {
	2511	+ if (dw_hdmi_support_scdc(hdmi, display)) {
2418	2512	if (vmode->mtmdsclock > HDMI14_MAX_TMDSCLK \|\|
2419	2513	(hdmi_info->scdc.scrambling.low_rates &&
2420	2514	hdmi->scramble_low_rates)) {
..	..	@@ -2512,25 +2606,26 @@
2512	2606	hdmi->mc_clkdis &= ~HDMI_MC_CLKDIS_TMDSCLK_DISABLE;
2513	2607	hdmi_writeb(hdmi, hdmi->mc_clkdis, HDMI_MC_CLKDIS);
2514	2608
2515		- /* Enable csc path */
2516		- if (is_color_space_conversion(hdmi)) {
2517		- hdmi->mc_clkdis &= ~HDMI_MC_CLKDIS_CSCCLK_DISABLE;
2518		- hdmi_writeb(hdmi, hdmi->mc_clkdis, HDMI_MC_CLKDIS);
2519		- }
2520		-
2521	2609	/* Enable pixel repetition path */
2522	2610	if (hdmi->hdmi_data.video_mode.mpixelrepetitioninput) {
2523	2611	hdmi->mc_clkdis &= ~HDMI_MC_CLKDIS_PREPCLK_DISABLE;
2524	2612	hdmi_writeb(hdmi, hdmi->mc_clkdis, HDMI_MC_CLKDIS);
2525	2613	}
2526	2614
2527		- /* Enable color space conversion if needed */
2528		- if (is_color_space_conversion(hdmi))
	2615	+ /* Enable csc path */
	2616	+ if (is_csc_needed(hdmi)) {
	2617	+ hdmi->mc_clkdis &= ~HDMI_MC_CLKDIS_CSCCLK_DISABLE;
	2618	+ hdmi_writeb(hdmi, hdmi->mc_clkdis, HDMI_MC_CLKDIS);
	2619	+
2529	2620	hdmi_writeb(hdmi, HDMI_MC_FLOWCTRL_FEED_THROUGH_OFF_CSC_IN_PATH,
2530	2621	HDMI_MC_FLOWCTRL);
2531		- else
	2622	+ } else {
	2623	+ hdmi->mc_clkdis \|= HDMI_MC_CLKDIS_CSCCLK_DISABLE;
	2624	+ hdmi_writeb(hdmi, hdmi->mc_clkdis, HDMI_MC_CLKDIS);
	2625	+
2532	2626	hdmi_writeb(hdmi, HDMI_MC_FLOWCTRL_FEED_THROUGH_OFF_CSC_BYPASS,
2533	2627	HDMI_MC_FLOWCTRL);
	2628	+ }
2534	2629	}
2535	2630
2536	2631	/* Workaround to clear the overflow condition */
..	..	@@ -2553,6 +2648,8 @@
2553	2648	* iteration for others.
2554	2649	* The Amlogic Meson GX SoCs (v2.01a) have been identified as needing
2555	2650	* the workaround with a single iteration.
	2651	+ * The Rockchip RK3288 SoC (v2.00a) and RK3328/RK3399 SoCs (v2.11a) have
	2652	+ * been identified as needing the workaround with a single iteration.
2556	2653	*/
2557	2654
2558	2655	switch (hdmi->version) {
..	..	@@ -2560,9 +2657,11 @@
2560	2657	count = 4;
2561	2658	break;
2562	2659	case 0x131a:
	2660	+ case 0x132a:
2563	2661	case 0x200a:
2564	2662	case 0x201a:
2565	2663	case 0x211a:
	2664	+ case 0x212a:
2566	2665	count = 1;
2567	2666	break;
2568	2667	default:
..	..	@@ -2583,7 +2682,7 @@
2583	2682	HDMI_IH_MUTE_FC_STAT2);
2584	2683	}
2585	2684
2586		-static void dw_hdmi_force_output_pattern(struct dw_hdmi hdmi, struct drm_display_mode mode)
	2685	+static void dw_hdmi_force_output_pattern(struct dw_hdmi hdmi, const struct drm_display_mode mode)
2587	2686	{
2588	2687	/* force output black */
2589	2688	if (hdmi_bus_fmt_is_rgb(hdmi->hdmi_data.enc_out_bus_format)) {
..	..	@@ -2615,7 +2714,9 @@
2615	2714	}
2616	2715	}
2617	2716
2618		-static int dw_hdmi_setup(struct dw_hdmi hdmi, struct drm_display_mode mode)
	2717	+static int dw_hdmi_setup(struct dw_hdmi *hdmi,
	2718	+ const struct drm_connector *connector,
	2719	+ const struct drm_display_mode *mode)
2619	2720	{
2620	2721	int ret;
2621	2722	void *data = hdmi->plat_data->phy_data;
..	..	@@ -2680,11 +2781,14 @@
2680	2781	else
2681	2782	hdmi->hdmi_data.enc_in_encoding = V4L2_YCBCR_ENC_DEFAULT;
2682	2783
	2784	+
2683	2785	if (hdmi->plat_data->get_quant_range)
2684	2786	hdmi->hdmi_data.quant_range =
2685	2787	hdmi->plat_data->get_quant_range(data);
2686		- else
2687		- hdmi->hdmi_data.quant_range = HDMI_QUANTIZATION_RANGE_DEFAULT;
	2788	+
	2789	+ hdmi->hdmi_data.rgb_limited_range = hdmi->sink_is_hdmi &&
	2790	+ drm_default_rgb_quant_range(mode) ==
	2791	+ HDMI_QUANTIZATION_RANGE_LIMITED;
2688	2792
2689	2793	if (!hdmi->sink_is_hdmi)
2690	2794	hdmi->hdmi_data.quant_range = HDMI_QUANTIZATION_RANGE_FULL;
..	..	@@ -2702,7 +2806,7 @@
2702	2806	dw_hdmi_force_output_pattern(hdmi, mode);
2703	2807
2704	2808	/* HDMI Initialization Step B.1 */
2705		- hdmi_av_composer(hdmi, mode);
	2809	+ hdmi_av_composer(hdmi, &connector->display_info, mode);
2706	2810
2707	2811	/* HDMI Initialization Step B.3 */
2708	2812	dw_hdmi_enable_video_path(hdmi);
..	..	@@ -2720,9 +2824,9 @@
2720	2824	dev_dbg(hdmi->dev, "%s HDMI mode\n", __func__);
2721	2825
2722	2826	/* HDMI Initialization Step F - Configure AVI InfoFrame */
2723		- hdmi_config_AVI(hdmi, mode);
2724		- hdmi_config_vendor_specific_infoframe(hdmi, mode);
2725		- hdmi_config_hdr_infoframe(hdmi);
	2827	+ hdmi_config_AVI(hdmi, connector, mode);
	2828	+ hdmi_config_vendor_specific_infoframe(hdmi, connector, mode);
	2829	+ hdmi_config_drm_infoframe(hdmi, connector);
2726	2830	} else {
2727	2831	dev_dbg(hdmi->dev, "%s DVI mode\n", __func__);
2728	2832	}
..	..	@@ -2739,6 +2843,7 @@
2739	2843	hdmi->hdmi_data.video_mode.previous_tmdsclock !=
2740	2844	hdmi->hdmi_data.video_mode.mtmdsclock) {
2741	2845	ret = hdmi->phy.ops->init(hdmi, hdmi->phy.data,
	2846	+ &connector->display_info,
2742	2847	&hdmi->previous_mode);
2743	2848	if (ret)
2744	2849	return ret;
..	..	@@ -2758,16 +2863,6 @@
2758	2863	}
2759	2864
2760	2865	return 0;
2761		-}
2762		-
2763		-static void dw_hdmi_setup_i2c(struct dw_hdmi *hdmi)
2764		-{
2765		- hdmi_writeb(hdmi, HDMI_PHY_I2CM_INT_ADDR_DONE_POL,
2766		- HDMI_PHY_I2CM_INT_ADDR);
2767		-
2768		- hdmi_writeb(hdmi, HDMI_PHY_I2CM_CTLINT_ADDR_NAC_POL \|
2769		- HDMI_PHY_I2CM_CTLINT_ADDR_ARBITRATION_POL,
2770		- HDMI_PHY_I2CM_CTLINT_ADDR);
2771	2866	}
2772	2867
2773	2868	static void initialize_hdmi_ih_mutes(struct dw_hdmi *hdmi)
..	..	@@ -2824,7 +2919,12 @@
2824	2919	static void dw_hdmi_poweron(struct dw_hdmi *hdmi)
2825	2920	{
2826	2921	hdmi->bridge_is_on = true;
2827		- dw_hdmi_setup(hdmi, &hdmi->previous_mode);
	2922	+
	2923	+ /*
	2924	+ * The curr_conn field is guaranteed to be valid here, as this function
	2925	+ * is only be called when !hdmi->disabled.
	2926	+ */
	2927	+ dw_hdmi_setup(hdmi, hdmi->curr_conn, &hdmi->previous_mode);
2828	2928	}
2829	2929
2830	2930	static void dw_hdmi_poweroff(struct dw_hdmi *hdmi)
..	..	@@ -2886,11 +2986,8 @@
2886	2986	hdmi->rxsense);
2887	2987	}
2888	2988
2889		-static enum drm_connector_status
2890		-dw_hdmi_connector_detect(struct drm_connector *connector, bool force)
	2989	+static enum drm_connector_status dw_hdmi_detect(struct dw_hdmi *hdmi)
2891	2990	{
2892		- struct dw_hdmi *hdmi = container_of(connector, struct dw_hdmi,
2893		- connector);
2894	2991	enum drm_connector_status result;
2895	2992
2896	2993	if (!hdmi->force_logo) {
..	..	@@ -2902,20 +2999,56 @@
2902	2999	}
2903	3000
2904	3001	result = hdmi->phy.ops->read_hpd(hdmi, hdmi->phy.data);
	3002	+ mutex_lock(&hdmi->mutex);
	3003	+ if (result != hdmi->last_connector_result) {
	3004	+ dev_dbg(hdmi->dev, "read_hpd result: %d", result);
	3005	+ handle_plugged_change(hdmi,
	3006	+ result == connector_status_connected);
	3007	+ hdmi->last_connector_result = result;
	3008	+ }
	3009	+ mutex_unlock(&hdmi->mutex);
	3010	+
2905	3011	if (result == connector_status_connected)
2906	3012	extcon_set_state_sync(hdmi->extcon, EXTCON_DISP_HDMI, true);
2907	3013	else
2908	3014	extcon_set_state_sync(hdmi->extcon, EXTCON_DISP_HDMI, false);
2909	3015
2910		- mutex_lock(&hdmi->mutex);
2911		- if (result != hdmi->last_connector_result) {
2912		- dev_dbg(hdmi->dev, "read_hpd result: %d", result);
2913		- handle_plugged_change(hdmi,
2914		- result == connector_status_connected);
2915		- hdmi->last_connector_result = result;
2916		- }
2917		- mutex_unlock(&hdmi->mutex);
2918	3016	return result;
	3017	+}
	3018	+
	3019	+static struct edid dw_hdmi_get_edid(struct dw_hdmi hdmi,
	3020	+ struct drm_connector *connector)
	3021	+{
	3022	+ struct edid *edid;
	3023	+
	3024	+ if (!hdmi->ddc)
	3025	+ return NULL;
	3026	+
	3027	+ edid = drm_get_edid(connector, hdmi->ddc);
	3028	+ if (!edid) {
	3029	+ dev_dbg(hdmi->dev, "failed to get edid\n");
	3030	+ return NULL;
	3031	+ }
	3032	+
	3033	+ dev_dbg(hdmi->dev, "got edid: width[%d] x height[%d]\n",
	3034	+ edid->width_cm, edid->height_cm);
	3035	+
	3036	+ hdmi->support_hdmi = drm_detect_hdmi_monitor(edid);
	3037	+ hdmi->sink_has_audio = drm_detect_monitor_audio(edid);
	3038	+
	3039	+ return edid;
	3040	+}
	3041	+
	3042	+/* -----------------------------------------------------------------------------
	3043	+ * DRM Connector Operations
	3044	+ */
	3045	+
	3046	+static enum drm_connector_status
	3047	+dw_hdmi_connector_detect(struct drm_connector *connector, bool force)
	3048	+{
	3049	+ struct dw_hdmi *hdmi = container_of(connector, struct dw_hdmi,
	3050	+ connector);
	3051	+ return dw_hdmi_detect(hdmi);
2919	3052	}
2920	3053
2921	3054	static int
..	..	@@ -2956,25 +3089,24 @@
2956	3089	struct edid *edid;
2957	3090	struct drm_display_mode *mode;
2958	3091	struct drm_display_info *info = &connector->display_info;
2959		- int i, ret = 0;
	3092	+ void *data = hdmi->plat_data->phy_data;
	3093	+ int i, ret = 0;
2960	3094
2961	3095	memset(metedata, 0, sizeof(*metedata));
2962		- if (!hdmi->ddc)
2963		- return 0;
2964		-
2965		- edid = drm_get_edid(connector, hdmi->ddc);
	3096	+#if 0
	3097	+ edid = dw_hdmi_get_edid(hdmi, connector);
2966	3098	if (edid) {
2967	3099	int vic = 0;
2968	3100
2969	3101	dev_dbg(hdmi->dev, "got edid: width[%d] x height[%d]\n",
2970	3102	edid->width_cm, edid->height_cm);
2971		-
2972		- hdmi->support_hdmi = drm_detect_hdmi_monitor(edid);
2973		- hdmi->sink_has_audio = drm_detect_monitor_audio(edid);
2974		- hdmi->rgb_quant_range_selectable = drm_rgb_quant_range_selectable(edid);
2975	3103	drm_connector_update_edid_property(connector, edid);
2976	3104	cec_notifier_set_phys_addr_from_edid(hdmi->cec_notifier, edid);
2977	3105	ret = drm_add_edid_modes(connector, edid);
	3106	+ if (hdmi->plat_data->get_color_changed)
	3107	+ hdmi->plat_data->get_yuv422_format(connector, edid);
	3108	+ if (hdmi->plat_data->get_colorimetry)
	3109	+ hdmi->plat_data->get_colorimetry(data, edid);
2978	3110
2979	3111	list_for_each_entry(mode, &connector->probed_modes, head) {
2980	3112	vic = drm_match_cea_mode(mode);
..	..	@@ -2989,10 +3121,9 @@
2989	3121
2990	3122	kfree(edid);
2991	3123	} else {
	3124	+#endif
2992	3125	hdmi->support_hdmi = true;
2993	3126	hdmi->sink_has_audio = true;
2994		- hdmi->rgb_quant_range_selectable = false;
2995		-
2996	3127	for (i = 0; i < ARRAY_SIZE(dw_hdmi_default_modes); i++) {
2997	3128	const struct drm_display_mode *ptr =
2998	3129	&dw_hdmi_default_modes[i];
..	..	@@ -3010,55 +3141,20 @@
3010	3141	info->color_formats = 0;
3011	3142
3012	3143	dev_info(hdmi->dev, "failed to get edid\n");
3013		- }
	3144	+// }
3014	3145	dw_hdmi_update_hdr_property(connector);
3015	3146	dw_hdmi_check_output_type_changed(hdmi);
3016	3147
3017	3148	return ret;
3018	3149	}
3019	3150
3020		-static int
3021		-dw_hdmi_atomic_connector_set_property(struct drm_connector *connector,
3022		- struct drm_connector_state *state,
3023		- struct drm_property *property,
3024		- uint64_t val)
	3151	+static struct drm_encoder *
	3152	+dw_hdmi_connector_best_encoder(struct drm_connector *connector)
3025	3153	{
3026	3154	struct dw_hdmi *hdmi = container_of(connector, struct dw_hdmi,
3027		- connector);
3028		- const struct dw_hdmi_property_ops *ops =
3029		- hdmi->plat_data->property_ops;
	3155	+ connector);
3030	3156
3031		- if (ops && ops->set_property)
3032		- return ops->set_property(connector, state, property,
3033		- val, hdmi->plat_data->phy_data);
3034		- else
3035		- return -EINVAL;
3036		-}
3037		-
3038		-static int
3039		-dw_hdmi_atomic_connector_get_property(struct drm_connector *connector,
3040		- const struct drm_connector_state *state,
3041		- struct drm_property *property,
3042		- uint64_t *val)
3043		-{
3044		- struct dw_hdmi *hdmi = container_of(connector, struct dw_hdmi,
3045		- connector);
3046		- const struct dw_hdmi_property_ops *ops =
3047		- hdmi->plat_data->property_ops;
3048		-
3049		- if (ops && ops->get_property)
3050		- return ops->get_property(connector, state, property,
3051		- val, hdmi->plat_data->phy_data);
3052		- else
3053		- return -EINVAL;
3054		-}
3055		-
3056		-static int
3057		-dw_hdmi_connector_set_property(struct drm_connector *connector,
3058		- struct drm_property *property, uint64_t val)
3059		-{
3060		- return dw_hdmi_atomic_connector_set_property(connector, NULL,
3061		- property, val);
	3157	+ return hdmi->bridge.encoder;
3062	3158	}
3063	3159
3064	3160	static bool dw_hdmi_color_changed(struct drm_connector *connector)
..	..	@@ -3140,22 +3236,6 @@
3140	3236	return false;
3141	3237	}
3142	3238
3143		-static bool check_hdmi_format_change(struct drm_connector_state *old_state,
3144		- struct drm_connector_state *new_state,
3145		- struct drm_connector *connector,
3146		- struct dw_hdmi *hdmi)
3147		-{
3148		- bool hdr_change, color_change;
3149		-
3150		- hdr_change = check_hdr_color_change(old_state, new_state, hdmi);
3151		- color_change = dw_hdmi_color_changed(connector);
3152		-
3153		- if (hdr_change \|\| color_change)
3154		- return true;
3155		-
3156		- return false;
3157		-}
3158		-
3159	3239	static int dw_hdmi_connector_atomic_check(struct drm_connector *connector,
3160	3240	struct drm_atomic_state *state)
3161	3241	{
..	..	@@ -3187,6 +3267,8 @@
3187	3267	if (!vmode->mpixelclock) {
3188	3268	u8 val;
3189	3269
	3270	+ hdmi->curr_conn = connector;
	3271	+
3190	3272	if (hdmi->plat_data->get_enc_in_encoding)
3191	3273	hdmi->hdmi_data.enc_in_encoding =
3192	3274	hdmi->plat_data->get_enc_in_encoding(data);
..	..	@@ -3210,10 +3292,6 @@
3210	3292	vmode->mtmdsclock /= 2;
3211	3293
3212	3294	dw_hdmi_force_output_pattern(hdmi, mode);
3213		-
3214		- hdmi_clk_regenerator_update_pixel_clock(hdmi);
3215		- hdmi_enable_audio_clk(hdmi, hdmi->audio_enable);
3216		-
3217	3295	drm_scdc_readb(hdmi->ddc, SCDC_TMDS_CONFIG, &val);
3218	3296
3219	3297	/* if plug out before hdmi bind, reset hdmi */
..	..	@@ -3221,8 +3299,8 @@
3221	3299	hdmi->logo_plug_out = true;
3222	3300	}
3223	3301
3224		- if (check_hdmi_format_change(old_state, new_state, connector, hdmi) \|\|
3225		- hdmi->logo_plug_out) {
	3302	+ if (check_hdr_color_change(old_state, new_state, hdmi) \|\| hdmi->logo_plug_out \|\|
	3303	+ dw_hdmi_color_changed(connector)) {
3226	3304	u32 mtmdsclk;
3227	3305
3228	3306	if (hdmi->plat_data->update_color_format)
..	..	@@ -3265,6 +3343,50 @@
3265	3343	return 0;
3266	3344	}
3267	3345
	3346	+static int
	3347	+dw_hdmi_atomic_connector_set_property(struct drm_connector *connector,
	3348	+ struct drm_connector_state *state,
	3349	+ struct drm_property *property,
	3350	+ uint64_t val)
	3351	+{
	3352	+ struct dw_hdmi *hdmi = container_of(connector, struct dw_hdmi,
	3353	+ connector);
	3354	+ const struct dw_hdmi_property_ops *ops =
	3355	+ hdmi->plat_data->property_ops;
	3356	+
	3357	+ if (ops && ops->set_property)
	3358	+ return ops->set_property(connector, state, property,
	3359	+ val, hdmi->plat_data->phy_data);
	3360	+ else
	3361	+ return -EINVAL;
	3362	+}
	3363	+
	3364	+static int
	3365	+dw_hdmi_atomic_connector_get_property(struct drm_connector *connector,
	3366	+ const struct drm_connector_state *state,
	3367	+ struct drm_property *property,
	3368	+ uint64_t *val)
	3369	+{
	3370	+ struct dw_hdmi *hdmi = container_of(connector, struct dw_hdmi,
	3371	+ connector);
	3372	+ const struct dw_hdmi_property_ops *ops =
	3373	+ hdmi->plat_data->property_ops;
	3374	+
	3375	+ if (ops && ops->get_property)
	3376	+ return ops->get_property(connector, state, property,
	3377	+ val, hdmi->plat_data->phy_data);
	3378	+ else
	3379	+ return -EINVAL;
	3380	+}
	3381	+
	3382	+static int
	3383	+dw_hdmi_connector_set_property(struct drm_connector *connector,
	3384	+ struct drm_property *property, uint64_t val)
	3385	+{
	3386	+ return dw_hdmi_atomic_connector_set_property(connector, NULL,
	3387	+ property, val);
	3388	+}
	3389	+
3268	3390	static void dw_hdmi_connector_atomic_commit(struct drm_connector *connector,
3269	3391	struct drm_connector_state *state)
3270	3392	{
..	..	@@ -3272,7 +3394,7 @@
3272	3394	container_of(connector, struct dw_hdmi, connector);
3273	3395
3274	3396	if (hdmi->update) {
3275		- dw_hdmi_setup(hdmi, &hdmi->previous_mode);
	3397	+ dw_hdmi_setup(hdmi, hdmi->curr_conn, &hdmi->previous_mode);
3276	3398	mdelay(50);
3277	3399	handle_plugged_change(hdmi, true);
3278	3400	hdmi_writeb(hdmi, HDMI_FC_GCP_CLEAR_AVMUTE, HDMI_FC_GCP);
..	..	@@ -3286,7 +3408,7 @@
3286	3408	return;
3287	3409
3288	3410	hdmi_writeb(hdmi, HDMI_FC_GCP_SET_AVMUTE, HDMI_FC_GCP);
3289		- dw_hdmi_setup(hdmi, &hdmi->previous_mode);
	3411	+ dw_hdmi_setup(hdmi, hdmi->curr_conn, &hdmi->previous_mode);
3290	3412	hdmi_writeb(hdmi, HDMI_FC_GCP_CLEAR_AVMUTE, HDMI_FC_GCP);
3291	3413	}
3292	3414	EXPORT_SYMBOL_GPL(dw_hdmi_set_quant_range);
..	..	@@ -3302,7 +3424,7 @@
3302	3424	return;
3303	3425
3304	3426	hdmi_writeb(hdmi, HDMI_FC_GCP_SET_AVMUTE, HDMI_FC_GCP);
3305		- dw_hdmi_setup(hdmi, &hdmi->previous_mode);
	3427	+ dw_hdmi_setup(hdmi, hdmi->curr_conn, &hdmi->previous_mode);
3306	3428	hdmi_writeb(hdmi, HDMI_FC_GCP_CLEAR_AVMUTE, HDMI_FC_GCP);
3307	3429	}
3308	3430	EXPORT_SYMBOL_GPL(dw_hdmi_set_output_type);
..	..	@@ -3324,7 +3446,11 @@
3324	3446	if (!hdmi->cec)
3325	3447	return;
3326	3448
3327		- dw_hdmi_hpd_wake_up(hdmi->cec);
	3449	+ if (!hdmi->cec_ops)
	3450	+ return;
	3451	+
	3452	+ if (hdmi->cec_ops->hpd_wake_up)
	3453	+ hdmi->cec_ops->hpd_wake_up(hdmi->cec);
3328	3454	}
3329	3455	EXPORT_SYMBOL_GPL(dw_hdmi_set_hpd_wake);
3330	3456
..	..	@@ -3365,7 +3491,7 @@
3365	3491
3366	3492	static const struct drm_connector_helper_funcs dw_hdmi_connector_helper_funcs = {
3367	3493	.get_modes = dw_hdmi_connector_get_modes,
3368		- .best_encoder = drm_atomic_helper_best_encoder,
	3494	+ .best_encoder = dw_hdmi_connector_best_encoder,
3369	3495	.atomic_check = dw_hdmi_connector_atomic_check,
3370	3496	.atomic_commit = dw_hdmi_connector_atomic_commit,
3371	3497	};
..	..	@@ -3436,7 +3562,7 @@
3436	3562	if (ops && ops->attach_properties)
3437	3563	return ops->attach_properties(&hdmi->connector,
3438	3564	color, hdmi->version,
3439		- hdmi->plat_data->phy_data);
	3565	+ hdmi->plat_data->phy_data, 0);
3440	3566	}
3441	3567
3442	3568	static void dw_hdmi_destroy_properties(struct dw_hdmi *hdmi)
..	..	@@ -3449,47 +3575,393 @@
3449	3575	hdmi->plat_data->phy_data);
3450	3576	}
3451	3577
3452		-static int dw_hdmi_bridge_attach(struct drm_bridge *bridge)
	3578	+static int dw_hdmi_connector_create(struct dw_hdmi *hdmi)
3453	3579	{
3454		- struct dw_hdmi *hdmi = bridge->driver_private;
3455		- struct drm_encoder *encoder = bridge->encoder;
3456	3580	struct drm_connector *connector = &hdmi->connector;
3457		- int ret;
	3581	+ struct cec_connector_info conn_info;
	3582	+ struct cec_notifier *notifier;
3458	3583
3459		- if (!hdmi->next_bridge) {
3460		- connector->interlace_allowed = 1;
3461		- connector->polled = DRM_CONNECTOR_POLL_HPD;
	3584	+ if (hdmi->version >= 0x200a)
	3585	+ connector->ycbcr_420_allowed =
	3586	+ hdmi->plat_data->ycbcr_420_allowed;
	3587	+ else
	3588	+ connector->ycbcr_420_allowed = false;
3462	3589
3463		- drm_connector_helper_add(connector, &dw_hdmi_connector_helper_funcs);
	3590	+ connector->interlace_allowed = 1;
	3591	+ connector->polled = DRM_CONNECTOR_POLL_HPD;
3464	3592
3465		- drm_connector_init(bridge->dev, connector, &dw_hdmi_connector_funcs,
3466		- DRM_MODE_CONNECTOR_HDMIA);
	3593	+ drm_connector_helper_add(connector, &dw_hdmi_connector_helper_funcs);
3467	3594
3468		- drm_connector_attach_encoder(connector, encoder);
	3595	+ drm_connector_init_with_ddc(hdmi->bridge.dev, connector,
	3596	+ &dw_hdmi_connector_funcs,
	3597	+ DRM_MODE_CONNECTOR_HDMIA,
	3598	+ hdmi->ddc);
3469	3599
3470		- dw_hdmi_attach_properties(hdmi);
	3600	+ /*
	3601	+ * drm_connector_attach_max_bpc_property() requires the
	3602	+ * connector to have a state.
	3603	+ */
	3604	+ drm_atomic_helper_connector_reset(connector);
3471	3605
3472		- return 0;
3473		- }
	3606	+ drm_connector_attach_max_bpc_property(connector, 8, 16);
3474	3607
3475		- hdmi->next_bridge->encoder = bridge->encoder;
3476		- ret = drm_bridge_attach(bridge->encoder, hdmi->next_bridge, bridge);
3477		- if (ret) {
3478		- DRM_ERROR("Failed to attach bridge with dw-hdmi\n");
3479		- return ret;
3480		- }
	3608	+ if (hdmi->version >= 0x200a && hdmi->plat_data->use_drm_infoframe)
	3609	+ drm_object_attach_property(&connector->base,
	3610	+ connector->dev->mode_config.hdr_output_metadata_property, 0);
3481	3611
3482		- bridge->next = hdmi->next_bridge;
	3612	+ drm_connector_attach_encoder(connector, hdmi->bridge.encoder);
	3613	+
	3614	+ dw_hdmi_attach_properties(hdmi);
	3615	+
	3616	+ cec_fill_conn_info_from_drm(&conn_info, connector);
	3617	+
	3618	+ notifier = cec_notifier_conn_register(hdmi->dev, NULL, &conn_info);
	3619	+ if (!notifier)
	3620	+ return -ENOMEM;
	3621	+
	3622	+ mutex_lock(&hdmi->cec_notifier_mutex);
	3623	+ hdmi->cec_notifier = notifier;
	3624	+ mutex_unlock(&hdmi->cec_notifier_mutex);
3483	3625
3484	3626	return 0;
3485	3627	}
3486	3628
	3629	+/* -----------------------------------------------------------------------------
	3630	+ * DRM Bridge Operations
	3631	+ */
	3632	+
	3633	+/*
	3634	+ * Possible output formats :
	3635	+ * - MEDIA_BUS_FMT_UYYVYY16_0_5X48,
	3636	+ * - MEDIA_BUS_FMT_UYYVYY12_0_5X36,
	3637	+ * - MEDIA_BUS_FMT_UYYVYY10_0_5X30,
	3638	+ * - MEDIA_BUS_FMT_UYYVYY8_0_5X24,
	3639	+ * - MEDIA_BUS_FMT_YUV16_1X48,
	3640	+ * - MEDIA_BUS_FMT_RGB161616_1X48,
	3641	+ * - MEDIA_BUS_FMT_UYVY12_1X24,
	3642	+ * - MEDIA_BUS_FMT_YUV12_1X36,
	3643	+ * - MEDIA_BUS_FMT_RGB121212_1X36,
	3644	+ * - MEDIA_BUS_FMT_UYVY10_1X20,
	3645	+ * - MEDIA_BUS_FMT_YUV10_1X30,
	3646	+ * - MEDIA_BUS_FMT_RGB101010_1X30,
	3647	+ * - MEDIA_BUS_FMT_UYVY8_1X16,
	3648	+ * - MEDIA_BUS_FMT_YUV8_1X24,
	3649	+ * - MEDIA_BUS_FMT_RGB888_1X24,
	3650	+ */
	3651	+
	3652	+/* Can return a maximum of 11 possible output formats for a mode/connector */
	3653	+#define MAX_OUTPUT_SEL_FORMATS 11
	3654	+
	3655	+static u32 dw_hdmi_bridge_atomic_get_output_bus_fmts(struct drm_bridge bridge,
	3656	+ struct drm_bridge_state *bridge_state,
	3657	+ struct drm_crtc_state *crtc_state,
	3658	+ struct drm_connector_state *conn_state,
	3659	+ unsigned int *num_output_fmts)
	3660	+{
	3661	+ struct drm_connector *conn = conn_state->connector;
	3662	+ struct drm_display_info *info = &conn->display_info;
	3663	+ struct drm_display_mode *mode = &crtc_state->mode;
	3664	+ u8 max_bpc = conn_state->max_requested_bpc;
	3665	+ bool is_hdmi2_sink = info->hdmi.scdc.supported \|\|
	3666	+ (info->color_formats & DRM_COLOR_FORMAT_YCRCB420);
	3667	+ u32 *output_fmts;
	3668	+ unsigned int i = 0;
	3669	+
	3670	+ *num_output_fmts = 0;
	3671	+
	3672	+ output_fmts = kcalloc(MAX_OUTPUT_SEL_FORMATS, sizeof(*output_fmts),
	3673	+ GFP_KERNEL);
	3674	+ if (!output_fmts)
	3675	+ return NULL;
	3676	+
	3677	+ /* If dw-hdmi is the first or only bridge, avoid negociating with ourselves */
	3678	+ if (list_is_singular(&bridge->encoder->bridge_chain) \|\|
	3679	+ list_is_first(&bridge->chain_node, &bridge->encoder->bridge_chain)) {
	3680	+ *num_output_fmts = 1;
	3681	+ output_fmts[0] = MEDIA_BUS_FMT_FIXED;
	3682	+
	3683	+ return output_fmts;
	3684	+ }
	3685	+
	3686	+ /*
	3687	+ * If the current mode enforces 4:2:0, force the output but format
	3688	+ * to 4:2:0 and do not add the YUV422/444/RGB formats
	3689	+ */
	3690	+ if (conn->ycbcr_420_allowed &&
	3691	+ (drm_mode_is_420_only(info, mode) \|\|
	3692	+ (is_hdmi2_sink && drm_mode_is_420_also(info, mode)))) {
	3693	+
	3694	+ /* Order bus formats from 16bit to 8bit if supported */
	3695	+ if (max_bpc >= 16 && info->bpc == 16 &&
	3696	+ (info->hdmi.y420_dc_modes & DRM_EDID_YCBCR420_DC_48))
	3697	+ output_fmts[i++] = MEDIA_BUS_FMT_UYYVYY16_0_5X48;
	3698	+
	3699	+ if (max_bpc >= 12 && info->bpc >= 12 &&
	3700	+ (info->hdmi.y420_dc_modes & DRM_EDID_YCBCR420_DC_36))
	3701	+ output_fmts[i++] = MEDIA_BUS_FMT_UYYVYY12_0_5X36;
	3702	+
	3703	+ if (max_bpc >= 10 && info->bpc >= 10 &&
	3704	+ (info->hdmi.y420_dc_modes & DRM_EDID_YCBCR420_DC_30))
	3705	+ output_fmts[i++] = MEDIA_BUS_FMT_UYYVYY10_0_5X30;
	3706	+
	3707	+ /* Default 8bit fallback */
	3708	+ output_fmts[i++] = MEDIA_BUS_FMT_UYYVYY8_0_5X24;
	3709	+
	3710	+ *num_output_fmts = i;
	3711	+
	3712	+ return output_fmts;
	3713	+ }
	3714	+
	3715	+ /*
	3716	+ * Order bus formats from 16bit to 8bit and from YUV422 to RGB
	3717	+ * if supported. In any case the default RGB888 format is added
	3718	+ */
	3719	+
	3720	+ /* Default 8bit RGB fallback */
	3721	+ output_fmts[i++] = MEDIA_BUS_FMT_RGB888_1X24;
	3722	+
	3723	+ if (max_bpc >= 16 && info->bpc == 16) {
	3724	+ if (info->color_formats & DRM_COLOR_FORMAT_YCRCB444)
	3725	+ output_fmts[i++] = MEDIA_BUS_FMT_YUV16_1X48;
	3726	+
	3727	+ output_fmts[i++] = MEDIA_BUS_FMT_RGB161616_1X48;
	3728	+ }
	3729	+
	3730	+ if (max_bpc >= 12 && info->bpc >= 12) {
	3731	+ if (info->color_formats & DRM_COLOR_FORMAT_YCRCB422)
	3732	+ output_fmts[i++] = MEDIA_BUS_FMT_UYVY12_1X24;
	3733	+
	3734	+ if (info->color_formats & DRM_COLOR_FORMAT_YCRCB444)
	3735	+ output_fmts[i++] = MEDIA_BUS_FMT_YUV12_1X36;
	3736	+
	3737	+ output_fmts[i++] = MEDIA_BUS_FMT_RGB121212_1X36;
	3738	+ }
	3739	+
	3740	+ if (max_bpc >= 10 && info->bpc >= 10) {
	3741	+ if (info->color_formats & DRM_COLOR_FORMAT_YCRCB422)
	3742	+ output_fmts[i++] = MEDIA_BUS_FMT_UYVY10_1X20;
	3743	+
	3744	+ if (info->color_formats & DRM_COLOR_FORMAT_YCRCB444)
	3745	+ output_fmts[i++] = MEDIA_BUS_FMT_YUV10_1X30;
	3746	+
	3747	+ output_fmts[i++] = MEDIA_BUS_FMT_RGB101010_1X30;
	3748	+ }
	3749	+
	3750	+ if (info->color_formats & DRM_COLOR_FORMAT_YCRCB422)
	3751	+ output_fmts[i++] = MEDIA_BUS_FMT_UYVY8_1X16;
	3752	+
	3753	+ if (info->color_formats & DRM_COLOR_FORMAT_YCRCB444)
	3754	+ output_fmts[i++] = MEDIA_BUS_FMT_YUV8_1X24;
	3755	+
	3756	+ *num_output_fmts = i;
	3757	+
	3758	+ return output_fmts;
	3759	+}
	3760	+
	3761	+/*
	3762	+ * Possible input formats :
	3763	+ * - MEDIA_BUS_FMT_RGB888_1X24
	3764	+ * - MEDIA_BUS_FMT_YUV8_1X24
	3765	+ * - MEDIA_BUS_FMT_UYVY8_1X16
	3766	+ * - MEDIA_BUS_FMT_UYYVYY8_0_5X24
	3767	+ * - MEDIA_BUS_FMT_RGB101010_1X30
	3768	+ * - MEDIA_BUS_FMT_YUV10_1X30
	3769	+ * - MEDIA_BUS_FMT_UYVY10_1X20
	3770	+ * - MEDIA_BUS_FMT_UYYVYY10_0_5X30
	3771	+ * - MEDIA_BUS_FMT_RGB121212_1X36
	3772	+ * - MEDIA_BUS_FMT_YUV12_1X36
	3773	+ * - MEDIA_BUS_FMT_UYVY12_1X24
	3774	+ * - MEDIA_BUS_FMT_UYYVYY12_0_5X36
	3775	+ * - MEDIA_BUS_FMT_RGB161616_1X48
	3776	+ * - MEDIA_BUS_FMT_YUV16_1X48
	3777	+ * - MEDIA_BUS_FMT_UYYVYY16_0_5X48
	3778	+ */
	3779	+
	3780	+/* Can return a maximum of 3 possible input formats for an output format */
	3781	+#define MAX_INPUT_SEL_FORMATS 3
	3782	+
	3783	+static u32 dw_hdmi_bridge_atomic_get_input_bus_fmts(struct drm_bridge bridge,
	3784	+ struct drm_bridge_state *bridge_state,
	3785	+ struct drm_crtc_state *crtc_state,
	3786	+ struct drm_connector_state *conn_state,
	3787	+ u32 output_fmt,
	3788	+ unsigned int *num_input_fmts)
	3789	+{
	3790	+ u32 *input_fmts;
	3791	+ unsigned int i = 0;
	3792	+
	3793	+ *num_input_fmts = 0;
	3794	+
	3795	+ input_fmts = kcalloc(MAX_INPUT_SEL_FORMATS, sizeof(*input_fmts),
	3796	+ GFP_KERNEL);
	3797	+ if (!input_fmts)
	3798	+ return NULL;
	3799	+
	3800	+ switch (output_fmt) {
	3801	+ /* If MEDIA_BUS_FMT_FIXED is tested, return default bus format */
	3802	+ case MEDIA_BUS_FMT_FIXED:
	3803	+ input_fmts[i++] = MEDIA_BUS_FMT_RGB888_1X24;
	3804	+ break;
	3805	+ /* 8bit */
	3806	+ case MEDIA_BUS_FMT_RGB888_1X24:
	3807	+ input_fmts[i++] = MEDIA_BUS_FMT_RGB888_1X24;
	3808	+ input_fmts[i++] = MEDIA_BUS_FMT_YUV8_1X24;
	3809	+ input_fmts[i++] = MEDIA_BUS_FMT_UYVY8_1X16;
	3810	+ break;
	3811	+ case MEDIA_BUS_FMT_YUV8_1X24:
	3812	+ input_fmts[i++] = MEDIA_BUS_FMT_YUV8_1X24;
	3813	+ input_fmts[i++] = MEDIA_BUS_FMT_UYVY8_1X16;
	3814	+ input_fmts[i++] = MEDIA_BUS_FMT_RGB888_1X24;
	3815	+ break;
	3816	+ case MEDIA_BUS_FMT_UYVY8_1X16:
	3817	+ input_fmts[i++] = MEDIA_BUS_FMT_UYVY8_1X16;
	3818	+ input_fmts[i++] = MEDIA_BUS_FMT_YUV8_1X24;
	3819	+ input_fmts[i++] = MEDIA_BUS_FMT_RGB888_1X24;
	3820	+ break;
	3821	+
	3822	+ /* 10bit */
	3823	+ case MEDIA_BUS_FMT_RGB101010_1X30:
	3824	+ input_fmts[i++] = MEDIA_BUS_FMT_RGB101010_1X30;
	3825	+ input_fmts[i++] = MEDIA_BUS_FMT_YUV10_1X30;
	3826	+ input_fmts[i++] = MEDIA_BUS_FMT_UYVY10_1X20;
	3827	+ break;
	3828	+ case MEDIA_BUS_FMT_YUV10_1X30:
	3829	+ input_fmts[i++] = MEDIA_BUS_FMT_YUV10_1X30;
	3830	+ input_fmts[i++] = MEDIA_BUS_FMT_UYVY10_1X20;
	3831	+ input_fmts[i++] = MEDIA_BUS_FMT_RGB101010_1X30;
	3832	+ break;
	3833	+ case MEDIA_BUS_FMT_UYVY10_1X20:
	3834	+ input_fmts[i++] = MEDIA_BUS_FMT_UYVY10_1X20;
	3835	+ input_fmts[i++] = MEDIA_BUS_FMT_YUV10_1X30;
	3836	+ input_fmts[i++] = MEDIA_BUS_FMT_RGB101010_1X30;
	3837	+ break;
	3838	+
	3839	+ /* 12bit */
	3840	+ case MEDIA_BUS_FMT_RGB121212_1X36:
	3841	+ input_fmts[i++] = MEDIA_BUS_FMT_RGB121212_1X36;
	3842	+ input_fmts[i++] = MEDIA_BUS_FMT_YUV12_1X36;
	3843	+ input_fmts[i++] = MEDIA_BUS_FMT_UYVY12_1X24;
	3844	+ break;
	3845	+ case MEDIA_BUS_FMT_YUV12_1X36:
	3846	+ input_fmts[i++] = MEDIA_BUS_FMT_YUV12_1X36;
	3847	+ input_fmts[i++] = MEDIA_BUS_FMT_UYVY12_1X24;
	3848	+ input_fmts[i++] = MEDIA_BUS_FMT_RGB121212_1X36;
	3849	+ break;
	3850	+ case MEDIA_BUS_FMT_UYVY12_1X24:
	3851	+ input_fmts[i++] = MEDIA_BUS_FMT_UYVY12_1X24;
	3852	+ input_fmts[i++] = MEDIA_BUS_FMT_YUV12_1X36;
	3853	+ input_fmts[i++] = MEDIA_BUS_FMT_RGB121212_1X36;
	3854	+ break;
	3855	+
	3856	+ /* 16bit */
	3857	+ case MEDIA_BUS_FMT_RGB161616_1X48:
	3858	+ input_fmts[i++] = MEDIA_BUS_FMT_RGB161616_1X48;
	3859	+ input_fmts[i++] = MEDIA_BUS_FMT_YUV16_1X48;
	3860	+ break;
	3861	+ case MEDIA_BUS_FMT_YUV16_1X48:
	3862	+ input_fmts[i++] = MEDIA_BUS_FMT_YUV16_1X48;
	3863	+ input_fmts[i++] = MEDIA_BUS_FMT_RGB161616_1X48;
	3864	+ break;
	3865	+
	3866	+ /YUV 4:2:0 /
	3867	+ case MEDIA_BUS_FMT_UYYVYY8_0_5X24:
	3868	+ case MEDIA_BUS_FMT_UYYVYY10_0_5X30:
	3869	+ case MEDIA_BUS_FMT_UYYVYY12_0_5X36:
	3870	+ case MEDIA_BUS_FMT_UYYVYY16_0_5X48:
	3871	+ input_fmts[i++] = output_fmt;
	3872	+ break;
	3873	+ }
	3874	+
	3875	+ *num_input_fmts = i;
	3876	+
	3877	+ if (*num_input_fmts == 0) {
	3878	+ kfree(input_fmts);
	3879	+ input_fmts = NULL;
	3880	+ }
	3881	+
	3882	+ return input_fmts;
	3883	+}
	3884	+
	3885	+static int dw_hdmi_bridge_atomic_check(struct drm_bridge *bridge,
	3886	+ struct drm_bridge_state *bridge_state,
	3887	+ struct drm_crtc_state *crtc_state,
	3888	+ struct drm_connector_state *conn_state)
	3889	+{
	3890	+ struct dw_hdmi *hdmi = bridge->driver_private;
	3891	+ void *data = hdmi->plat_data->phy_data;
	3892	+
	3893	+ if (bridge_state->output_bus_cfg.format == MEDIA_BUS_FMT_FIXED) {
	3894	+ if (hdmi->plat_data->get_output_bus_format)
	3895	+ hdmi->hdmi_data.enc_out_bus_format =
	3896	+ hdmi->plat_data->get_output_bus_format(data);
	3897	+ else
	3898	+ hdmi->hdmi_data.enc_out_bus_format =
	3899	+ MEDIA_BUS_FMT_RGB888_1X24;
	3900	+
	3901	+ if (hdmi->plat_data->get_input_bus_format)
	3902	+ hdmi->hdmi_data.enc_in_bus_format =
	3903	+ hdmi->plat_data->get_input_bus_format(data);
	3904	+ else if (hdmi->plat_data->input_bus_format)
	3905	+ hdmi->hdmi_data.enc_in_bus_format =
	3906	+ hdmi->plat_data->input_bus_format;
	3907	+ else
	3908	+ hdmi->hdmi_data.enc_in_bus_format =
	3909	+ MEDIA_BUS_FMT_RGB888_1X24;
	3910	+ } else {
	3911	+ hdmi->hdmi_data.enc_out_bus_format =
	3912	+ bridge_state->output_bus_cfg.format;
	3913	+
	3914	+ hdmi->hdmi_data.enc_in_bus_format =
	3915	+ bridge_state->input_bus_cfg.format;
	3916	+
	3917	+ dev_dbg(hdmi->dev, "input format 0x%04x, output format 0x%04x\n",
	3918	+ bridge_state->input_bus_cfg.format,
	3919	+ bridge_state->output_bus_cfg.format);
	3920	+ }
	3921	+
	3922	+ return 0;
	3923	+}
	3924	+
	3925	+static int dw_hdmi_bridge_attach(struct drm_bridge *bridge,
	3926	+ enum drm_bridge_attach_flags flags)
	3927	+{
	3928	+ struct dw_hdmi *hdmi = bridge->driver_private;
	3929	+ int ret;
	3930	+
	3931	+ if (flags & DRM_BRIDGE_ATTACH_NO_CONNECTOR)
	3932	+ return 0;
	3933	+
	3934	+ if (hdmi->next_bridge) {
	3935	+ hdmi->next_bridge->encoder = bridge->encoder;
	3936	+ ret = drm_bridge_attach(bridge->encoder, hdmi->next_bridge, bridge, flags);
	3937	+ if (ret) {
	3938	+ DRM_ERROR("Failed to attach bridge with dw-hdmi\n");
	3939	+ return ret;
	3940	+ }
	3941	+
	3942	+ return 0;
	3943	+ }
	3944	+
	3945	+ return dw_hdmi_connector_create(hdmi);
	3946	+}
	3947	+
	3948	+static void dw_hdmi_bridge_detach(struct drm_bridge *bridge)
	3949	+{
	3950	+ struct dw_hdmi *hdmi = bridge->driver_private;
	3951	+
	3952	+ mutex_lock(&hdmi->cec_notifier_mutex);
	3953	+ cec_notifier_conn_unregister(hdmi->cec_notifier);
	3954	+ hdmi->cec_notifier = NULL;
	3955	+ mutex_unlock(&hdmi->cec_notifier_mutex);
	3956	+}
	3957	+
3487	3958	static enum drm_mode_status
3488	3959	dw_hdmi_bridge_mode_valid(struct drm_bridge *bridge,
	3960	+ const struct drm_display_info *info,
3489	3961	const struct drm_display_mode *mode)
3490	3962	{
3491	3963	struct dw_hdmi *hdmi = bridge->driver_private;
3492		- struct drm_connector *connector = &hdmi->connector;
	3964	+ const struct dw_hdmi_plat_data *pdata = hdmi->plat_data;
3493	3965	enum drm_mode_status mode_status = MODE_OK;
3494	3966
3495	3967	if (hdmi->next_bridge)
..	..	@@ -3498,15 +3970,16 @@
3498	3970	if (!(hdmi_readb(hdmi, HDMI_PHY_STAT0) & HDMI_PHY_HPD) && hdmi->hdr2sdr)
3499	3971	return MODE_OK;
3500	3972
3501		- if (hdmi->plat_data->mode_valid)
3502		- mode_status = hdmi->plat_data->mode_valid(connector, mode);
	3973	+ if (pdata->mode_valid)
	3974	+ mode_status = pdata->mode_valid(hdmi, pdata->priv_data, info,
	3975	+ mode);
3503	3976
3504	3977	return mode_status;
3505	3978	}
3506	3979
3507	3980	static void dw_hdmi_bridge_mode_set(struct drm_bridge *bridge,
3508		- struct drm_display_mode *orig_mode,
3509		- struct drm_display_mode *mode)
	3981	+ const struct drm_display_mode *orig_mode,
	3982	+ const struct drm_display_mode *mode)
3510	3983	{
3511	3984	struct dw_hdmi *hdmi = bridge->driver_private;
3512	3985
..	..	@@ -3518,7 +3991,8 @@
3518	3991	mutex_unlock(&hdmi->mutex);
3519	3992	}
3520	3993
3521		-static void dw_hdmi_bridge_disable(struct drm_bridge *bridge)
	3994	+static void dw_hdmi_bridge_atomic_disable(struct drm_bridge *bridge,
	3995	+ struct drm_bridge_state *old_state)
3522	3996	{
3523	3997	struct dw_hdmi *hdmi = bridge->driver_private;
3524	3998	void *data = hdmi->plat_data->phy_data;
..	..	@@ -3526,6 +4000,7 @@
3526	4000	mutex_lock(&hdmi->mutex);
3527	4001	hdmi->disabled = true;
3528	4002	handle_plugged_change(hdmi, false);
	4003	+ hdmi->curr_conn = NULL;
3529	4004	dw_hdmi_update_power(hdmi);
3530	4005	dw_hdmi_update_phy_mask(hdmi);
3531	4006	if (hdmi->plat_data->dclk_set)
..	..	@@ -3538,12 +4013,19 @@
3538	4013	mutex_unlock(&hdmi->i2c->lock);
3539	4014	}
3540	4015
3541		-static void dw_hdmi_bridge_enable(struct drm_bridge *bridge)
	4016	+static void dw_hdmi_bridge_atomic_enable(struct drm_bridge *bridge,
	4017	+ struct drm_bridge_state *old_state)
3542	4018	{
3543	4019	struct dw_hdmi *hdmi = bridge->driver_private;
	4020	+ struct drm_atomic_state *state = old_state->base.state;
	4021	+ struct drm_connector *connector;
	4022	+
	4023	+ connector = drm_atomic_get_new_connector_for_encoder(state,
	4024	+ bridge->encoder);
3544	4025
3545	4026	mutex_lock(&hdmi->mutex);
3546	4027	hdmi->disabled = false;
	4028	+ hdmi->curr_conn = connector;
3547	4029	if (hdmi->plat_data->dclk_set)
3548	4030	hdmi->plat_data->dclk_set(hdmi->plat_data->phy_data, true, 0);
3549	4031	dw_hdmi_update_power(hdmi);
..	..	@@ -3552,13 +4034,47 @@
3552	4034	mutex_unlock(&hdmi->mutex);
3553	4035	}
3554	4036
	4037	+static enum drm_connector_status dw_hdmi_bridge_detect(struct drm_bridge *bridge)
	4038	+{
	4039	+ struct dw_hdmi *hdmi = bridge->driver_private;
	4040	+
	4041	+ return dw_hdmi_detect(hdmi);
	4042	+}
	4043	+
	4044	+static struct edid dw_hdmi_bridge_get_edid(struct drm_bridge bridge,
	4045	+ struct drm_connector *connector)
	4046	+{
	4047	+ struct dw_hdmi *hdmi = bridge->driver_private;
	4048	+
	4049	+ return dw_hdmi_get_edid(hdmi, connector);
	4050	+}
	4051	+
3555	4052	static const struct drm_bridge_funcs dw_hdmi_bridge_funcs = {
	4053	+ .atomic_duplicate_state = drm_atomic_helper_bridge_duplicate_state,
	4054	+ .atomic_destroy_state = drm_atomic_helper_bridge_destroy_state,
	4055	+ .atomic_reset = drm_atomic_helper_bridge_reset,
3556	4056	.attach = dw_hdmi_bridge_attach,
3557		- .enable = dw_hdmi_bridge_enable,
3558		- .disable = dw_hdmi_bridge_disable,
	4057	+ .detach = dw_hdmi_bridge_detach,
	4058	+ .atomic_check = dw_hdmi_bridge_atomic_check,
	4059	+ .atomic_get_output_bus_fmts = dw_hdmi_bridge_atomic_get_output_bus_fmts,
	4060	+ .atomic_get_input_bus_fmts = dw_hdmi_bridge_atomic_get_input_bus_fmts,
	4061	+ .atomic_enable = dw_hdmi_bridge_atomic_enable,
	4062	+ .atomic_disable = dw_hdmi_bridge_atomic_disable,
3559	4063	.mode_set = dw_hdmi_bridge_mode_set,
3560	4064	.mode_valid = dw_hdmi_bridge_mode_valid,
	4065	+ .detect = dw_hdmi_bridge_detect,
	4066	+ .get_edid = dw_hdmi_bridge_get_edid,
3561	4067	};
	4068	+
	4069	+void dw_hdmi_set_cec_adap(struct dw_hdmi hdmi, struct cec_adapter adap)
	4070	+{
	4071	+ hdmi->cec_adap = adap;
	4072	+}
	4073	+EXPORT_SYMBOL_GPL(dw_hdmi_set_cec_adap);
	4074	+
	4075	+/* -----------------------------------------------------------------------------
	4076	+ * IRQ Handling
	4077	+ */
3562	4078
3563	4079	static irqreturn_t dw_hdmi_i2c_irq(struct dw_hdmi *hdmi)
3564	4080	{
..	..	@@ -3668,9 +4184,11 @@
3668	4184	phy_stat & HDMI_PHY_HPD,
3669	4185	phy_stat & HDMI_PHY_RX_SENSE);
3670	4186
3671		- if ((phy_stat & (HDMI_PHY_RX_SENSE \| HDMI_PHY_HPD)) == 0)
3672		- cec_notifier_set_phys_addr(hdmi->cec_notifier,
3673		- CEC_PHYS_ADDR_INVALID);
	4187	+ if ((phy_stat & (HDMI_PHY_RX_SENSE \| HDMI_PHY_HPD)) == 0) {
	4188	+ mutex_lock(&hdmi->cec_notifier_mutex);
	4189	+ cec_notifier_phys_addr_invalidate(hdmi->cec_notifier);
	4190	+ mutex_unlock(&hdmi->cec_notifier_mutex);
	4191	+ }
3674	4192	}
3675	4193
3676	4194	check_hdmi_irq(hdmi, intr_stat, phy_int_pol);
..	..	@@ -3813,6 +4331,22 @@
3813	4331	.max_register = HDMI_I2CM_SCDC_UPDATE1 << 2,
3814	4332	};
3815	4333
	4334	+static void dw_hdmi_init_hw(struct dw_hdmi *hdmi)
	4335	+{
	4336	+ initialize_hdmi_ih_mutes(hdmi);
	4337	+
	4338	+ /*
	4339	+ * Reset HDMI DDC I2C master controller and mute I2CM interrupts.
	4340	+ * Even if we are using a separate i2c adapter doing this doesn't
	4341	+ * hurt.
	4342	+ */
	4343	+ if (hdmi->i2c)
	4344	+ dw_hdmi_i2c_init(hdmi);
	4345	+
	4346	+ if (hdmi->phy.ops->setup_hpd)
	4347	+ hdmi->phy.ops->setup_hpd(hdmi, hdmi->phy.data);
	4348	+}
	4349	+
3816	4350	static int dw_hdmi_status_show(struct seq_file s, void v)
3817	4351	{
3818	4352	struct dw_hdmi *hdmi = s->private;
..	..	@@ -3871,22 +4405,22 @@
3871	4405	}
3872	4406
3873	4407	val = hdmi_readb(hdmi, HDMI_FC_PACKET_TX_EN);
3874		- if (!(val & HDMI_FC_PACKET_DRM_TX_EN_MASK)) {
	4408	+ if (!(val & HDMI_FC_PACKET_TX_EN_DRM_MASK)) {
3875	4409	seq_puts(s, "Off\n");
3876	4410	return 0;
3877	4411	}
3878	4412
3879	4413	switch (hdmi_readb(hdmi, HDMI_FC_DRM_PB0)) {
3880		- case TRADITIONAL_GAMMA_SDR:
	4414	+ case HDMI_EOTF_TRADITIONAL_GAMMA_SDR:
3881	4415	seq_puts(s, "SDR");
3882	4416	break;
3883		- case TRADITIONAL_GAMMA_HDR:
	4417	+ case HDMI_EOTF_TRADITIONAL_GAMMA_HDR:
3884	4418	seq_puts(s, "HDR");
3885	4419	break;
3886		- case SMPTE_ST2084:
	4420	+ case HDMI_EOTF_SMPTE_ST2084:
3887	4421	seq_puts(s, "ST2084");
3888	4422	break;
3889		- case HLG:
	4423	+ case HDMI_EOTF_BT_2100_HLG:
3890	4424	seq_puts(s, "HLG");
3891	4425	break;
3892	4426	default:
..	..	@@ -4163,9 +4697,22 @@
4163	4697	return 0;
4164	4698	}
4165	4699
4166		-static struct dw_hdmi *
4167		-__dw_hdmi_probe(struct platform_device *pdev,
4168		- const struct dw_hdmi_plat_data *plat_data)
	4700	+void
	4701	+dw_hdmi_cec_wake_ops_register(struct dw_hdmi hdmi, const struct dw_hdmi_cec_wake_ops cec_ops)
	4702	+{
	4703	+ if (!cec_ops \|\| !hdmi)
	4704	+ return;
	4705	+
	4706	+ hdmi->cec_ops = cec_ops;
	4707	+}
	4708	+EXPORT_SYMBOL_GPL(dw_hdmi_cec_wake_ops_register);
	4709	+
	4710	+
	4711	+/* -----------------------------------------------------------------------------
	4712	+ * Probe/remove API, used from platforms based on the DRM bridge API.
	4713	+ */
	4714	+struct dw_hdmi dw_hdmi_probe(struct platform_device pdev,
	4715	+ const struct dw_hdmi_plat_data *plat_data)
4169	4716	{
4170	4717	struct device *dev = &pdev->dev;
4171	4718	struct device_node *np = dev->of_node;
..	..	@@ -4191,7 +4738,6 @@
4191	4738	hdmi->connector.stereo_allowed = 1;
4192	4739	hdmi->plat_data = plat_data;
4193	4740	hdmi->dev = dev;
4194		- hdmi->audio_enable = true;
4195	4741	hdmi->sample_rate = 48000;
4196	4742	hdmi->disabled = true;
4197	4743	hdmi->rxsense = true;
..	..	@@ -4201,6 +4747,7 @@
4201	4747
4202	4748	mutex_init(&hdmi->mutex);
4203	4749	mutex_init(&hdmi->audio_mutex);
	4750	+ mutex_init(&hdmi->cec_notifier_mutex);
4204	4751	spin_lock_init(&hdmi->audio_lock);
4205	4752
4206	4753	ddc_node = of_parse_phandle(np, "ddc-i2c-bus", 0);
..	..	@@ -4344,7 +4891,6 @@
4344	4891	}
4345	4892
4346	4893	init_hpd_work(hdmi);
4347		- initialize_hdmi_ih_mutes(hdmi);
4348	4894
4349	4895	irq = platform_get_irq(pdev, 0);
4350	4896	if (irq < 0) {
..	..	@@ -4359,12 +4905,6 @@
4359	4905	if (ret)
4360	4906	goto err_iahb;
4361	4907
4362		- hdmi->cec_notifier = cec_notifier_get(dev);
4363		- if (!hdmi->cec_notifier) {
4364		- ret = -ENOMEM;
4365		- goto err_iahb;
4366		- }
4367		-
4368	4908	/*
4369	4909	* To prevent overflows in HDMI_IH_FC_STAT2, set the clk regenerator
4370	4910	* N and cts values before enabling phy
..	..	@@ -4373,6 +4913,24 @@
4373	4913
4374	4914	/* If DDC bus is not specified, try to register HDMI I2C bus */
4375	4915	if (!hdmi->ddc) {
	4916	+ /* Look for (optional) stuff related to unwedging */
	4917	+ hdmi->pinctrl = devm_pinctrl_get(dev);
	4918	+ if (!IS_ERR(hdmi->pinctrl)) {
	4919	+ hdmi->unwedge_state =
	4920	+ pinctrl_lookup_state(hdmi->pinctrl, "unwedge");
	4921	+ hdmi->default_state =
	4922	+ pinctrl_lookup_state(hdmi->pinctrl, "default");
	4923	+
	4924	+ if (IS_ERR(hdmi->default_state) \|\|
	4925	+ IS_ERR(hdmi->unwedge_state)) {
	4926	+ if (!IS_ERR(hdmi->unwedge_state))
	4927	+ dev_warn(dev,
	4928	+ "Unwedge requires default pinctrl\n");
	4929	+ hdmi->default_state = NULL;
	4930	+ hdmi->unwedge_state = NULL;
	4931	+ }
	4932	+ }
	4933	+
4376	4934	hdmi->ddc = dw_hdmi_i2c_adapter(hdmi);
4377	4935	if (IS_ERR(hdmi->ddc))
4378	4936	hdmi->ddc = NULL;
..	..	@@ -4388,8 +4946,12 @@
4388	4946	hdmi->i2c->scl_low_ns = 4916;
4389	4947	}
4390	4948
	4949	+ dw_hdmi_init_hw(hdmi);
	4950	+
4391	4951	hdmi->bridge.driver_private = hdmi;
4392	4952	hdmi->bridge.funcs = &dw_hdmi_bridge_funcs;
	4953	+ hdmi->bridge.ops = DRM_BRIDGE_OP_DETECT \| DRM_BRIDGE_OP_EDID
	4954	+ \| DRM_BRIDGE_OP_HPD;
4393	4955	#ifdef CONFIG_OF
4394	4956	hdmi->bridge.of_node = pdev->dev.of_node;
4395	4957	#endif
..	..	@@ -4418,16 +4980,6 @@
4418	4980	hdmi->sink_has_audio = true;
4419	4981	}
4420	4982
4421		- dw_hdmi_setup_i2c(hdmi);
4422		- if (hdmi->phy.ops->setup_hpd)
4423		- hdmi->phy.ops->setup_hpd(hdmi, hdmi->phy.data);
4424		-
4425		- if (hdmi->version >= 0x200a)
4426		- hdmi->connector.ycbcr_420_allowed =
4427		- hdmi->plat_data->ycbcr_420_allowed;
4428		- else
4429		- hdmi->connector.ycbcr_420_allowed = false;
4430		-
4431	4983	memset(&pdevinfo, 0, sizeof(pdevinfo));
4432	4984	pdevinfo.parent = dev;
4433	4985	pdevinfo.id = PLATFORM_DEVID_AUTO;
..	..	@@ -4442,7 +4994,7 @@
4442	4994	audio.base = hdmi->regs;
4443	4995	audio.irq = irq;
4444	4996	audio.hdmi = hdmi;
4445		- audio.eld = hdmi->connector.eld;
	4997	+ audio.get_eld = hdmi_audio_get_eld;
4446	4998	hdmi->enable_audio = dw_hdmi_ahb_audio_enable;
4447	4999	hdmi->disable_audio = dw_hdmi_ahb_audio_disable;
4448	5000
..	..	@@ -4455,9 +5007,9 @@
4455	5007	struct dw_hdmi_i2s_audio_data audio;
4456	5008
4457	5009	audio.hdmi = hdmi;
	5010	+ audio.get_eld = hdmi_audio_get_eld;
4458	5011	audio.write = hdmi_writeb;
4459	5012	audio.read = hdmi_readb;
4460		- audio.mod = hdmi_modb;
4461	5013	hdmi->enable_audio = dw_hdmi_i2s_audio_enable;
4462	5014	hdmi->disable_audio = dw_hdmi_i2s_audio_disable;
4463	5015
..	..	@@ -4510,9 +5062,7 @@
4510	5062	goto err_iahb;
4511	5063	}
4512	5064
4513		- /* Reset HDMI DDC I2C master controller and mute I2CM interrupts */
4514		- if (hdmi->i2c)
4515		- dw_hdmi_i2c_init(hdmi);
	5065	+ drm_bridge_add(&hdmi->bridge);
4516	5066
4517	5067	dw_hdmi_register_debugfs(dev, hdmi);
4518	5068
..	..	@@ -4526,26 +5076,22 @@
4526	5076	return hdmi;
4527	5077
4528	5078	err_iahb:
4529		- if (hdmi->i2c) {
4530		- i2c_del_adapter(&hdmi->i2c->adap);
4531		- hdmi->ddc = NULL;
4532		- }
4533		-
4534		- if (hdmi->cec_notifier)
4535		- cec_notifier_put(hdmi->cec_notifier);
4536		-
4537	5079	clk_disable_unprepare(hdmi->iahb_clk);
4538	5080	if (hdmi->cec_clk)
4539	5081	clk_disable_unprepare(hdmi->cec_clk);
4540	5082	err_isfr:
4541	5083	clk_disable_unprepare(hdmi->isfr_clk);
4542	5084	err_res:
4543		- i2c_put_adapter(hdmi->ddc);
	5085	+ if (hdmi->i2c)
	5086	+ i2c_del_adapter(&hdmi->i2c->adap);
	5087	+ else
	5088	+ i2c_put_adapter(hdmi->ddc);
4544	5089
4545	5090	return ERR_PTR(ret);
4546	5091	}
	5092	+EXPORT_SYMBOL_GPL(dw_hdmi_probe);
4547	5093
4548		-static void __dw_hdmi_remove(struct dw_hdmi *hdmi)
	5094	+void dw_hdmi_remove(struct dw_hdmi *hdmi)
4549	5095	{
4550	5096	if (hdmi->irq)
4551	5097	disable_irq(hdmi->irq);
..	..	@@ -4555,6 +5101,8 @@
4555	5101	destroy_workqueue(hdmi->workqueue);
4556	5102
4557	5103	debugfs_remove_recursive(hdmi->debugfs_dir);
	5104	+
	5105	+ drm_bridge_remove(&hdmi->bridge);
4558	5106
4559	5107	if (hdmi->audio && !IS_ERR(hdmi->audio))
4560	5108	platform_device_unregister(hdmi->audio);
..	..	@@ -4574,9 +5122,6 @@
4574	5122	if (hdmi->bridge.encoder)
4575	5123	hdmi->bridge.encoder->funcs->destroy(hdmi->bridge.encoder);
4576	5124
4577		- if (hdmi->cec_notifier)
4578		- cec_notifier_put(hdmi->cec_notifier);
4579		-
4580	5125	clk_disable_unprepare(hdmi->iahb_clk);
4581	5126	clk_disable_unprepare(hdmi->isfr_clk);
4582	5127	if (hdmi->cec_clk)
..	..	@@ -4586,31 +5131,6 @@
4586	5131	i2c_del_adapter(&hdmi->i2c->adap);
4587	5132	else
4588	5133	i2c_put_adapter(hdmi->ddc);
4589		-}
4590		-
4591		-/* -----------------------------------------------------------------------------
4592		- * Probe/remove API, used from platforms based on the DRM bridge API.
4593		- */
4594		-struct dw_hdmi dw_hdmi_probe(struct platform_device pdev,
4595		- const struct dw_hdmi_plat_data *plat_data)
4596		-{
4597		- struct dw_hdmi *hdmi;
4598		-
4599		- hdmi = __dw_hdmi_probe(pdev, plat_data);
4600		- if (IS_ERR(hdmi))
4601		- return hdmi;
4602		-
4603		- drm_bridge_add(&hdmi->bridge);
4604		-
4605		- return hdmi;
4606		-}
4607		-EXPORT_SYMBOL_GPL(dw_hdmi_probe);
4608		-
4609		-void dw_hdmi_remove(struct dw_hdmi *hdmi)
4610		-{
4611		- drm_bridge_remove(&hdmi->bridge);
4612		-
4613		- __dw_hdmi_remove(hdmi);
4614	5134	}
4615	5135	EXPORT_SYMBOL_GPL(dw_hdmi_remove);
4616	5136
..	..	@@ -4624,13 +5144,13 @@
4624	5144	struct dw_hdmi *hdmi;
4625	5145	int ret;
4626	5146
4627		- hdmi = __dw_hdmi_probe(pdev, plat_data);
	5147	+ hdmi = dw_hdmi_probe(pdev, plat_data);
4628	5148	if (IS_ERR(hdmi))
4629	5149	return hdmi;
4630	5150
4631		- ret = drm_bridge_attach(encoder, &hdmi->bridge, NULL);
	5151	+ ret = drm_bridge_attach(encoder, &hdmi->bridge, NULL, 0);
4632	5152	if (ret) {
4633		- __dw_hdmi_remove(hdmi);
	5153	+ dw_hdmi_remove(hdmi);
4634	5154	DRM_ERROR("Failed to initialize bridge with drm\n");
4635	5155	return ERR_PTR(ret);
4636	5156	}
..	..	@@ -4644,7 +5164,7 @@
4644	5164
4645	5165	void dw_hdmi_unbind(struct dw_hdmi *hdmi)
4646	5166	{
4647		- __dw_hdmi_remove(hdmi);
	5167	+ dw_hdmi_remove(hdmi);
4648	5168	}
4649	5169	EXPORT_SYMBOL_GPL(dw_hdmi_unbind);
4650	5170
..	..	@@ -4673,12 +5193,10 @@
4673	5193	}
4674	5194	}
4675	5195
4676		-void dw_hdmi_suspend(struct device dev, struct dw_hdmi hdmi)
	5196	+void dw_hdmi_suspend(struct dw_hdmi *hdmi)
4677	5197	{
4678		- if (!hdmi) {
4679		- dev_warn(dev, "Hdmi has not been initialized\n");
	5198	+ if (!hdmi)
4680	5199	return;
4681		- }
4682	5200
4683	5201	mutex_lock(&hdmi->mutex);
4684	5202
..	..	@@ -4699,18 +5217,16 @@
4699	5217	disable_irq(hdmi->irq);
4700	5218	cancel_delayed_work(&hdmi->work);
4701	5219	flush_workqueue(hdmi->workqueue);
4702		- pinctrl_pm_select_sleep_state(dev);
	5220	+ pinctrl_pm_select_sleep_state(hdmi->dev);
4703	5221	}
4704	5222	EXPORT_SYMBOL_GPL(dw_hdmi_suspend);
4705	5223
4706		-void dw_hdmi_resume(struct device dev, struct dw_hdmi hdmi)
	5224	+void dw_hdmi_resume(struct dw_hdmi *hdmi)
4707	5225	{
4708		- if (!hdmi) {
4709		- dev_warn(dev, "Hdmi has not been initialized\n");
	5226	+ if (!hdmi)
4710	5227	return;
4711		- }
4712	5228
4713		- pinctrl_pm_select_default_state(dev);
	5229	+ pinctrl_pm_select_default_state(hdmi->dev);
4714	5230	mutex_lock(&hdmi->mutex);
4715	5231	dw_hdmi_reg_initial(hdmi);
4716	5232	if (hdmi->i2c)