1 /*
2  * Copyright (C) 2016 BayLibre, SAS
3  * Author: Neil Armstrong <narmstrong@baylibre.com>
4  * Copyright (C) 2015 Amlogic, Inc. All rights reserved.
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License as
8  * published by the Free Software Foundation; either version 2 of the
9  * License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful, but
12  * WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, see <http://www.gnu.org/licenses/>.
18  */
19 
20 #include <linux/kernel.h>
21 #include <linux/module.h>
22 #include <linux/component.h>
23 #include <linux/of_graph.h>
24 #include <linux/reset.h>
25 #include <linux/clk.h>
26 #include <linux/regulator/consumer.h>
27 
28 #include <drm/drmP.h>
29 #include <drm/drm_edid.h>
30 #include <drm/drm_crtc_helper.h>
31 #include <drm/drm_atomic_helper.h>
32 #include <drm/bridge/dw_hdmi.h>
33 
34 #include <uapi/linux/media-bus-format.h>
35 #include <uapi/linux/videodev2.h>
36 
37 #include "meson_drv.h"
38 #include "meson_venc.h"
39 #include "meson_vclk.h"
40 #include "meson_dw_hdmi.h"
41 #include "meson_registers.h"
42 
43 #define DRIVER_NAME "meson-dw-hdmi"
44 #define DRIVER_DESC "Amlogic Meson HDMI-TX DRM driver"
45 
46 /**
47  * DOC: HDMI Output
48  *
49  * HDMI Output is composed of :
50  *
51  * - A Synopsys DesignWare HDMI Controller IP
52  * - A TOP control block controlling the Clocks and PHY
53  * - A custom HDMI PHY in order convert video to TMDS signal
54  *
55  * .. code::
56  *
57  *    ___________________________________
58  *   |            HDMI TOP               |<= HPD
59  *   |___________________________________|
60  *   |                  |                |
61  *   |  Synopsys HDMI   |   HDMI PHY     |=> TMDS
62  *   |    Controller    |________________|
63  *   |___________________________________|<=> DDC
64  *
65  *
66  * The HDMI TOP block only supports HPD sensing.
67  * The Synopsys HDMI Controller interrupt is routed
68  * through the TOP Block interrupt.
69  * Communication to the TOP Block and the Synopsys
70  * HDMI Controller is done a pair of addr+read/write
71  * registers.
72  * The HDMI PHY is configured by registers in the
73  * HHI register block.
74  *
75  * Pixel data arrives in 4:4:4 format from the VENC
76  * block and the VPU HDMI mux selects either the ENCI
77  * encoder for the 576i or 480i formats or the ENCP
78  * encoder for all the other formats including
79  * interlaced HD formats.
80  * The VENC uses a DVI encoder on top of the ENCI
81  * or ENCP encoders to generate DVI timings for the
82  * HDMI controller.
83  *
84  * GXBB, GXL and GXM embeds the Synopsys DesignWare
85  * HDMI TX IP version 2.01a with HDCP and I2C & S/PDIF
86  * audio source interfaces.
87  *
88  * We handle the following features :
89  *
90  * - HPD Rise & Fall interrupt
91  * - HDMI Controller Interrupt
92  * - HDMI PHY Init for 480i to 1080p60
93  * - VENC & HDMI Clock setup for 480i to 1080p60
94  * - VENC Mode setup for 480i to 1080p60
95  *
96  * What is missing :
97  *
98  * - PHY, Clock and Mode setup for 2k && 4k modes
99  * - SDDC Scrambling mode for HDMI 2.0a
100  * - HDCP Setup
101  * - CEC Management
102  */
103 
104 /* TOP Block Communication Channel */
105 #define HDMITX_TOP_ADDR_REG	0x0
106 #define HDMITX_TOP_DATA_REG	0x4
107 #define HDMITX_TOP_CTRL_REG	0x8
108 
109 /* Controller Communication Channel */
110 #define HDMITX_DWC_ADDR_REG	0x10
111 #define HDMITX_DWC_DATA_REG	0x14
112 #define HDMITX_DWC_CTRL_REG	0x18
113 
114 /* HHI Registers */
115 #define HHI_MEM_PD_REG0		0x100 /* 0x40 */
116 #define HHI_HDMI_CLK_CNTL	0x1cc /* 0x73 */
117 #define HHI_HDMI_PHY_CNTL0	0x3a0 /* 0xe8 */
118 #define HHI_HDMI_PHY_CNTL1	0x3a4 /* 0xe9 */
119 #define HHI_HDMI_PHY_CNTL2	0x3a8 /* 0xea */
120 #define HHI_HDMI_PHY_CNTL3	0x3ac /* 0xeb */
121 
122 static DEFINE_SPINLOCK(reg_lock);
123 
124 enum meson_venc_source {
125 	MESON_VENC_SOURCE_NONE = 0,
126 	MESON_VENC_SOURCE_ENCI = 1,
127 	MESON_VENC_SOURCE_ENCP = 2,
128 };
129 
130 struct meson_dw_hdmi {
131 	struct drm_encoder encoder;
132 	struct dw_hdmi_plat_data dw_plat_data;
133 	struct meson_drm *priv;
134 	struct device *dev;
135 	void __iomem *hdmitx;
136 	struct reset_control *hdmitx_apb;
137 	struct reset_control *hdmitx_ctrl;
138 	struct reset_control *hdmitx_phy;
139 	struct clk *hdmi_pclk;
140 	struct clk *venci_clk;
141 	struct regulator *hdmi_supply;
142 	u32 irq_stat;
143 	struct dw_hdmi *hdmi;
144 };
145 #define encoder_to_meson_dw_hdmi(x) \
146 	container_of(x, struct meson_dw_hdmi, encoder)
147 
148 static inline int dw_hdmi_is_compatible(struct meson_dw_hdmi *dw_hdmi,
149 					const char *compat)
150 {
151 	return of_device_is_compatible(dw_hdmi->dev->of_node, compat);
152 }
153 
154 /* PHY (via TOP bridge) and Controller dedicated register interface */
155 
156 static unsigned int dw_hdmi_top_read(struct meson_dw_hdmi *dw_hdmi,
157 				     unsigned int addr)
158 {
159 	unsigned long flags;
160 	unsigned int data;
161 
162 	spin_lock_irqsave(&reg_lock, flags);
163 
164 	/* ADDR must be written twice */
165 	writel(addr & 0xffff, dw_hdmi->hdmitx + HDMITX_TOP_ADDR_REG);
166 	writel(addr & 0xffff, dw_hdmi->hdmitx + HDMITX_TOP_ADDR_REG);
167 
168 	/* Read needs a second DATA read */
169 	data = readl(dw_hdmi->hdmitx + HDMITX_TOP_DATA_REG);
170 	data = readl(dw_hdmi->hdmitx + HDMITX_TOP_DATA_REG);
171 
172 	spin_unlock_irqrestore(&reg_lock, flags);
173 
174 	return data;
175 }
176 
177 static inline void dw_hdmi_top_write(struct meson_dw_hdmi *dw_hdmi,
178 				     unsigned int addr, unsigned int data)
179 {
180 	unsigned long flags;
181 
182 	spin_lock_irqsave(&reg_lock, flags);
183 
184 	/* ADDR must be written twice */
185 	writel(addr & 0xffff, dw_hdmi->hdmitx + HDMITX_TOP_ADDR_REG);
186 	writel(addr & 0xffff, dw_hdmi->hdmitx + HDMITX_TOP_ADDR_REG);
187 
188 	/* Write needs single DATA write */
189 	writel(data, dw_hdmi->hdmitx + HDMITX_TOP_DATA_REG);
190 
191 	spin_unlock_irqrestore(&reg_lock, flags);
192 }
193 
194 /* Helper to change specific bits in PHY registers */
195 static inline void dw_hdmi_top_write_bits(struct meson_dw_hdmi *dw_hdmi,
196 					  unsigned int addr,
197 					  unsigned int mask,
198 					  unsigned int val)
199 {
200 	unsigned int data = dw_hdmi_top_read(dw_hdmi, addr);
201 
202 	data &= ~mask;
203 	data |= val;
204 
205 	dw_hdmi_top_write(dw_hdmi, addr, data);
206 }
207 
208 static unsigned int dw_hdmi_dwc_read(struct meson_dw_hdmi *dw_hdmi,
209 				     unsigned int addr)
210 {
211 	unsigned long flags;
212 	unsigned int data;
213 
214 	spin_lock_irqsave(&reg_lock, flags);
215 
216 	/* ADDR must be written twice */
217 	writel(addr & 0xffff, dw_hdmi->hdmitx + HDMITX_DWC_ADDR_REG);
218 	writel(addr & 0xffff, dw_hdmi->hdmitx + HDMITX_DWC_ADDR_REG);
219 
220 	/* Read needs a second DATA read */
221 	data = readl(dw_hdmi->hdmitx + HDMITX_DWC_DATA_REG);
222 	data = readl(dw_hdmi->hdmitx + HDMITX_DWC_DATA_REG);
223 
224 	spin_unlock_irqrestore(&reg_lock, flags);
225 
226 	return data;
227 }
228 
229 static inline void dw_hdmi_dwc_write(struct meson_dw_hdmi *dw_hdmi,
230 				     unsigned int addr, unsigned int data)
231 {
232 	unsigned long flags;
233 
234 	spin_lock_irqsave(&reg_lock, flags);
235 
236 	/* ADDR must be written twice */
237 	writel(addr & 0xffff, dw_hdmi->hdmitx + HDMITX_DWC_ADDR_REG);
238 	writel(addr & 0xffff, dw_hdmi->hdmitx + HDMITX_DWC_ADDR_REG);
239 
240 	/* Write needs single DATA write */
241 	writel(data, dw_hdmi->hdmitx + HDMITX_DWC_DATA_REG);
242 
243 	spin_unlock_irqrestore(&reg_lock, flags);
244 }
245 
246 /* Helper to change specific bits in controller registers */
247 static inline void dw_hdmi_dwc_write_bits(struct meson_dw_hdmi *dw_hdmi,
248 					  unsigned int addr,
249 					  unsigned int mask,
250 					  unsigned int val)
251 {
252 	unsigned int data = dw_hdmi_dwc_read(dw_hdmi, addr);
253 
254 	data &= ~mask;
255 	data |= val;
256 
257 	dw_hdmi_dwc_write(dw_hdmi, addr, data);
258 }
259 
260 /* Bridge */
261 
262 /* Setup PHY bandwidth modes */
263 static void meson_hdmi_phy_setup_mode(struct meson_dw_hdmi *dw_hdmi,
264 				      struct drm_display_mode *mode)
265 {
266 	struct meson_drm *priv = dw_hdmi->priv;
267 	unsigned int pixel_clock = mode->clock;
268 
269 	if (dw_hdmi_is_compatible(dw_hdmi, "amlogic,meson-gxl-dw-hdmi") ||
270 	    dw_hdmi_is_compatible(dw_hdmi, "amlogic,meson-gxm-dw-hdmi")) {
271 		if (pixel_clock >= 371250) {
272 			/* 5.94Gbps, 3.7125Gbps */
273 			regmap_write(priv->hhi, HHI_HDMI_PHY_CNTL0, 0x333d3282);
274 			regmap_write(priv->hhi, HHI_HDMI_PHY_CNTL3, 0x2136315b);
275 		} else if (pixel_clock >= 297000) {
276 			/* 2.97Gbps */
277 			regmap_write(priv->hhi, HHI_HDMI_PHY_CNTL0, 0x33303382);
278 			regmap_write(priv->hhi, HHI_HDMI_PHY_CNTL3, 0x2036315b);
279 		} else if (pixel_clock >= 148500) {
280 			/* 1.485Gbps */
281 			regmap_write(priv->hhi, HHI_HDMI_PHY_CNTL0, 0x33303362);
282 			regmap_write(priv->hhi, HHI_HDMI_PHY_CNTL3, 0x2016315b);
283 		} else {
284 			/* 742.5Mbps, and below */
285 			regmap_write(priv->hhi, HHI_HDMI_PHY_CNTL0, 0x33604142);
286 			regmap_write(priv->hhi, HHI_HDMI_PHY_CNTL3, 0x0016315b);
287 		}
288 	} else if (dw_hdmi_is_compatible(dw_hdmi,
289 					 "amlogic,meson-gxbb-dw-hdmi")) {
290 		if (pixel_clock >= 371250) {
291 			/* 5.94Gbps, 3.7125Gbps */
292 			regmap_write(priv->hhi, HHI_HDMI_PHY_CNTL0, 0x33353245);
293 			regmap_write(priv->hhi, HHI_HDMI_PHY_CNTL3, 0x2100115b);
294 		} else if (pixel_clock >= 297000) {
295 			/* 2.97Gbps */
296 			regmap_write(priv->hhi, HHI_HDMI_PHY_CNTL0, 0x33634283);
297 			regmap_write(priv->hhi, HHI_HDMI_PHY_CNTL3, 0xb000115b);
298 		} else {
299 			/* 1.485Gbps, and below */
300 			regmap_write(priv->hhi, HHI_HDMI_PHY_CNTL0, 0x33632122);
301 			regmap_write(priv->hhi, HHI_HDMI_PHY_CNTL3, 0x2000115b);
302 		}
303 	}
304 }
305 
306 static inline void meson_dw_hdmi_phy_reset(struct meson_dw_hdmi *dw_hdmi)
307 {
308 	struct meson_drm *priv = dw_hdmi->priv;
309 
310 	/* Enable and software reset */
311 	regmap_update_bits(priv->hhi, HHI_HDMI_PHY_CNTL1, 0xf, 0xf);
312 
313 	mdelay(2);
314 
315 	/* Enable and unreset */
316 	regmap_update_bits(priv->hhi, HHI_HDMI_PHY_CNTL1, 0xf, 0xe);
317 
318 	mdelay(2);
319 }
320 
321 static void dw_hdmi_set_vclk(struct meson_dw_hdmi *dw_hdmi,
322 			     struct drm_display_mode *mode)
323 {
324 	struct meson_drm *priv = dw_hdmi->priv;
325 	int vic = drm_match_cea_mode(mode);
326 	unsigned int vclk_freq;
327 	unsigned int venc_freq;
328 	unsigned int hdmi_freq;
329 
330 	vclk_freq = mode->clock;
331 
332 	if (!vic) {
333 		meson_vclk_setup(priv, MESON_VCLK_TARGET_DMT, vclk_freq,
334 				 vclk_freq, vclk_freq, false);
335 		return;
336 	}
337 
338 	if (mode->flags & DRM_MODE_FLAG_DBLCLK)
339 		vclk_freq *= 2;
340 
341 	venc_freq = vclk_freq;
342 	hdmi_freq = vclk_freq;
343 
344 	if (meson_venc_hdmi_venc_repeat(vic))
345 		venc_freq *= 2;
346 
347 	vclk_freq = max(venc_freq, hdmi_freq);
348 
349 	if (mode->flags & DRM_MODE_FLAG_DBLCLK)
350 		venc_freq /= 2;
351 
352 	DRM_DEBUG_DRIVER("vclk:%d venc=%d hdmi=%d enci=%d\n",
353 		vclk_freq, venc_freq, hdmi_freq,
354 		priv->venc.hdmi_use_enci);
355 
356 	meson_vclk_setup(priv, MESON_VCLK_TARGET_HDMI, vclk_freq,
357 			 venc_freq, hdmi_freq, priv->venc.hdmi_use_enci);
358 }
359 
360 static int dw_hdmi_phy_init(struct dw_hdmi *hdmi, void *data,
361 			    struct drm_display_mode *mode)
362 {
363 	struct meson_dw_hdmi *dw_hdmi = (struct meson_dw_hdmi *)data;
364 	struct meson_drm *priv = dw_hdmi->priv;
365 	unsigned int wr_clk =
366 		readl_relaxed(priv->io_base + _REG(VPU_HDMI_SETTING));
367 
368 	DRM_DEBUG_DRIVER("%d:\"%s\"\n", mode->base.id, mode->name);
369 
370 	/* Enable clocks */
371 	regmap_update_bits(priv->hhi, HHI_HDMI_CLK_CNTL, 0xffff, 0x100);
372 
373 	/* Bring HDMITX MEM output of power down */
374 	regmap_update_bits(priv->hhi, HHI_MEM_PD_REG0, 0xff << 8, 0);
375 
376 	/* Bring out of reset */
377 	dw_hdmi_top_write(dw_hdmi, HDMITX_TOP_SW_RESET,  0);
378 
379 	/* Enable internal pixclk, tmds_clk, spdif_clk, i2s_clk, cecclk */
380 	dw_hdmi_top_write_bits(dw_hdmi, HDMITX_TOP_CLK_CNTL,
381 			       0x3, 0x3);
382 	dw_hdmi_top_write_bits(dw_hdmi, HDMITX_TOP_CLK_CNTL,
383 			       0x3 << 4, 0x3 << 4);
384 
385 	/* Enable normal output to PHY */
386 	dw_hdmi_top_write(dw_hdmi, HDMITX_TOP_BIST_CNTL, BIT(12));
387 
388 	/* TMDS pattern setup (TOFIX pattern for 4k2k scrambling) */
389 	dw_hdmi_top_write(dw_hdmi, HDMITX_TOP_TMDS_CLK_PTTN_01, 0x001f001f);
390 	dw_hdmi_top_write(dw_hdmi, HDMITX_TOP_TMDS_CLK_PTTN_23, 0x001f001f);
391 
392 	/* Load TMDS pattern */
393 	dw_hdmi_top_write(dw_hdmi, HDMITX_TOP_TMDS_CLK_PTTN_CNTL, 0x1);
394 	msleep(20);
395 	dw_hdmi_top_write(dw_hdmi, HDMITX_TOP_TMDS_CLK_PTTN_CNTL, 0x2);
396 
397 	/* Setup PHY parameters */
398 	meson_hdmi_phy_setup_mode(dw_hdmi, mode);
399 
400 	/* Setup PHY */
401 	regmap_update_bits(priv->hhi, HHI_HDMI_PHY_CNTL1,
402 			   0xffff << 16, 0x0390 << 16);
403 
404 	/* BIT_INVERT */
405 	if (dw_hdmi_is_compatible(dw_hdmi, "amlogic,meson-gxl-dw-hdmi") ||
406 	    dw_hdmi_is_compatible(dw_hdmi, "amlogic,meson-gxm-dw-hdmi"))
407 		regmap_update_bits(priv->hhi, HHI_HDMI_PHY_CNTL1,
408 				   BIT(17), 0);
409 	else
410 		regmap_update_bits(priv->hhi, HHI_HDMI_PHY_CNTL1,
411 				   BIT(17), BIT(17));
412 
413 	/* Disable clock, fifo, fifo_wr */
414 	regmap_update_bits(priv->hhi, HHI_HDMI_PHY_CNTL1, 0xf, 0);
415 
416 	msleep(100);
417 
418 	/* Reset PHY 3 times in a row */
419 	meson_dw_hdmi_phy_reset(dw_hdmi);
420 	meson_dw_hdmi_phy_reset(dw_hdmi);
421 	meson_dw_hdmi_phy_reset(dw_hdmi);
422 
423 	/* Temporary Disable VENC video stream */
424 	if (priv->venc.hdmi_use_enci)
425 		writel_relaxed(0, priv->io_base + _REG(ENCI_VIDEO_EN));
426 	else
427 		writel_relaxed(0, priv->io_base + _REG(ENCP_VIDEO_EN));
428 
429 	/* Temporary Disable HDMI video stream to HDMI-TX */
430 	writel_bits_relaxed(0x3, 0,
431 			    priv->io_base + _REG(VPU_HDMI_SETTING));
432 	writel_bits_relaxed(0xf << 8, 0,
433 			    priv->io_base + _REG(VPU_HDMI_SETTING));
434 
435 	/* Re-Enable VENC video stream */
436 	if (priv->venc.hdmi_use_enci)
437 		writel_relaxed(1, priv->io_base + _REG(ENCI_VIDEO_EN));
438 	else
439 		writel_relaxed(1, priv->io_base + _REG(ENCP_VIDEO_EN));
440 
441 	/* Push back HDMI clock settings */
442 	writel_bits_relaxed(0xf << 8, wr_clk & (0xf << 8),
443 			    priv->io_base + _REG(VPU_HDMI_SETTING));
444 
445 	/* Enable and Select HDMI video source for HDMI-TX */
446 	if (priv->venc.hdmi_use_enci)
447 		writel_bits_relaxed(0x3, MESON_VENC_SOURCE_ENCI,
448 				    priv->io_base + _REG(VPU_HDMI_SETTING));
449 	else
450 		writel_bits_relaxed(0x3, MESON_VENC_SOURCE_ENCP,
451 				    priv->io_base + _REG(VPU_HDMI_SETTING));
452 
453 	return 0;
454 }
455 
456 static void dw_hdmi_phy_disable(struct dw_hdmi *hdmi,
457 				void *data)
458 {
459 	struct meson_dw_hdmi *dw_hdmi = (struct meson_dw_hdmi *)data;
460 	struct meson_drm *priv = dw_hdmi->priv;
461 
462 	DRM_DEBUG_DRIVER("\n");
463 
464 	regmap_write(priv->hhi, HHI_HDMI_PHY_CNTL0, 0);
465 }
466 
467 static enum drm_connector_status dw_hdmi_read_hpd(struct dw_hdmi *hdmi,
468 			     void *data)
469 {
470 	struct meson_dw_hdmi *dw_hdmi = (struct meson_dw_hdmi *)data;
471 
472 	return !!dw_hdmi_top_read(dw_hdmi, HDMITX_TOP_STAT0) ?
473 		connector_status_connected : connector_status_disconnected;
474 }
475 
476 static void dw_hdmi_setup_hpd(struct dw_hdmi *hdmi,
477 			      void *data)
478 {
479 	struct meson_dw_hdmi *dw_hdmi = (struct meson_dw_hdmi *)data;
480 
481 	/* Setup HPD Filter */
482 	dw_hdmi_top_write(dw_hdmi, HDMITX_TOP_HPD_FILTER,
483 			  (0xa << 12) | 0xa0);
484 
485 	/* Clear interrupts */
486 	dw_hdmi_top_write(dw_hdmi, HDMITX_TOP_INTR_STAT_CLR,
487 			  HDMITX_TOP_INTR_HPD_RISE | HDMITX_TOP_INTR_HPD_FALL);
488 
489 	/* Unmask interrupts */
490 	dw_hdmi_top_write_bits(dw_hdmi, HDMITX_TOP_INTR_MASKN,
491 			HDMITX_TOP_INTR_HPD_RISE | HDMITX_TOP_INTR_HPD_FALL,
492 			HDMITX_TOP_INTR_HPD_RISE | HDMITX_TOP_INTR_HPD_FALL);
493 }
494 
495 static const struct dw_hdmi_phy_ops meson_dw_hdmi_phy_ops = {
496 	.init = dw_hdmi_phy_init,
497 	.disable = dw_hdmi_phy_disable,
498 	.read_hpd = dw_hdmi_read_hpd,
499 	.setup_hpd = dw_hdmi_setup_hpd,
500 };
501 
502 static irqreturn_t dw_hdmi_top_irq(int irq, void *dev_id)
503 {
504 	struct meson_dw_hdmi *dw_hdmi = dev_id;
505 	u32 stat;
506 
507 	stat = dw_hdmi_top_read(dw_hdmi, HDMITX_TOP_INTR_STAT);
508 	dw_hdmi_top_write(dw_hdmi, HDMITX_TOP_INTR_STAT_CLR, stat);
509 
510 	/* HPD Events, handle in the threaded interrupt handler */
511 	if (stat & (HDMITX_TOP_INTR_HPD_RISE | HDMITX_TOP_INTR_HPD_FALL)) {
512 		dw_hdmi->irq_stat = stat;
513 		return IRQ_WAKE_THREAD;
514 	}
515 
516 	/* HDMI Controller Interrupt */
517 	if (stat & 1)
518 		return IRQ_NONE;
519 
520 	/* TOFIX Handle HDCP Interrupts */
521 
522 	return IRQ_HANDLED;
523 }
524 
525 /* Threaded interrupt handler to manage HPD events */
526 static irqreturn_t dw_hdmi_top_thread_irq(int irq, void *dev_id)
527 {
528 	struct meson_dw_hdmi *dw_hdmi = dev_id;
529 	u32 stat = dw_hdmi->irq_stat;
530 
531 	/* HPD Events */
532 	if (stat & (HDMITX_TOP_INTR_HPD_RISE | HDMITX_TOP_INTR_HPD_FALL)) {
533 		bool hpd_connected = false;
534 
535 		if (stat & HDMITX_TOP_INTR_HPD_RISE)
536 			hpd_connected = true;
537 
538 		dw_hdmi_setup_rx_sense(dw_hdmi->hdmi, hpd_connected,
539 				       hpd_connected);
540 
541 		drm_helper_hpd_irq_event(dw_hdmi->encoder.dev);
542 	}
543 
544 	return IRQ_HANDLED;
545 }
546 
547 static enum drm_mode_status
548 dw_hdmi_mode_valid(struct drm_connector *connector,
549 		   const struct drm_display_mode *mode)
550 {
551 	struct meson_drm *priv = connector->dev->dev_private;
552 	unsigned int vclk_freq;
553 	unsigned int venc_freq;
554 	unsigned int hdmi_freq;
555 	int vic = drm_match_cea_mode(mode);
556 	enum drm_mode_status status;
557 
558 	DRM_DEBUG_DRIVER("Modeline %d:\"%s\" %d %d %d %d %d %d %d %d %d %d 0x%x 0x%x\n",
559 		mode->base.id, mode->name, mode->vrefresh, mode->clock,
560 		mode->hdisplay, mode->hsync_start,
561 		mode->hsync_end, mode->htotal,
562 		mode->vdisplay, mode->vsync_start,
563 		mode->vsync_end, mode->vtotal, mode->type, mode->flags);
564 
565 	/* Check against non-VIC supported modes */
566 	if (!vic) {
567 		status = meson_venc_hdmi_supported_mode(mode);
568 		if (status != MODE_OK)
569 			return status;
570 
571 		return meson_vclk_dmt_supported_freq(priv, mode->clock);
572 	/* Check against supported VIC modes */
573 	} else if (!meson_venc_hdmi_supported_vic(vic))
574 		return MODE_BAD;
575 
576 	vclk_freq = mode->clock;
577 
578 	/* 480i/576i needs global pixel doubling */
579 	if (mode->flags & DRM_MODE_FLAG_DBLCLK)
580 		vclk_freq *= 2;
581 
582 	venc_freq = vclk_freq;
583 	hdmi_freq = vclk_freq;
584 
585 	/* VENC double pixels for 1080i and 720p modes */
586 	if (meson_venc_hdmi_venc_repeat(vic))
587 		venc_freq *= 2;
588 
589 	vclk_freq = max(venc_freq, hdmi_freq);
590 
591 	if (mode->flags & DRM_MODE_FLAG_DBLCLK)
592 		venc_freq /= 2;
593 
594 	dev_dbg(connector->dev->dev, "%s: vclk:%d venc=%d hdmi=%d\n", __func__,
595 		vclk_freq, venc_freq, hdmi_freq);
596 
597 	/* Finally filter by configurable vclk frequencies for VIC modes */
598 	switch (vclk_freq) {
599 	case 54000:
600 	case 74250:
601 	case 148500:
602 	case 297000:
603 	case 594000:
604 		return MODE_OK;
605 	}
606 
607 	return MODE_CLOCK_RANGE;
608 }
609 
610 /* Encoder */
611 
612 static void meson_venc_hdmi_encoder_destroy(struct drm_encoder *encoder)
613 {
614 	drm_encoder_cleanup(encoder);
615 }
616 
617 static const struct drm_encoder_funcs meson_venc_hdmi_encoder_funcs = {
618 	.destroy        = meson_venc_hdmi_encoder_destroy,
619 };
620 
621 static int meson_venc_hdmi_encoder_atomic_check(struct drm_encoder *encoder,
622 					struct drm_crtc_state *crtc_state,
623 					struct drm_connector_state *conn_state)
624 {
625 	return 0;
626 }
627 
628 static void meson_venc_hdmi_encoder_disable(struct drm_encoder *encoder)
629 {
630 	struct meson_dw_hdmi *dw_hdmi = encoder_to_meson_dw_hdmi(encoder);
631 	struct meson_drm *priv = dw_hdmi->priv;
632 
633 	DRM_DEBUG_DRIVER("\n");
634 
635 	writel_bits_relaxed(0x3, 0,
636 			    priv->io_base + _REG(VPU_HDMI_SETTING));
637 
638 	writel_relaxed(0, priv->io_base + _REG(ENCI_VIDEO_EN));
639 	writel_relaxed(0, priv->io_base + _REG(ENCP_VIDEO_EN));
640 }
641 
642 static void meson_venc_hdmi_encoder_enable(struct drm_encoder *encoder)
643 {
644 	struct meson_dw_hdmi *dw_hdmi = encoder_to_meson_dw_hdmi(encoder);
645 	struct meson_drm *priv = dw_hdmi->priv;
646 
647 	DRM_DEBUG_DRIVER("%s\n", priv->venc.hdmi_use_enci ? "VENCI" : "VENCP");
648 
649 	if (priv->venc.hdmi_use_enci)
650 		writel_relaxed(1, priv->io_base + _REG(ENCI_VIDEO_EN));
651 	else
652 		writel_relaxed(1, priv->io_base + _REG(ENCP_VIDEO_EN));
653 }
654 
655 static void meson_venc_hdmi_encoder_mode_set(struct drm_encoder *encoder,
656 				   struct drm_display_mode *mode,
657 				   struct drm_display_mode *adjusted_mode)
658 {
659 	struct meson_dw_hdmi *dw_hdmi = encoder_to_meson_dw_hdmi(encoder);
660 	struct meson_drm *priv = dw_hdmi->priv;
661 	int vic = drm_match_cea_mode(mode);
662 
663 	DRM_DEBUG_DRIVER("%d:\"%s\" vic %d\n",
664 			 mode->base.id, mode->name, vic);
665 
666 	/* VENC + VENC-DVI Mode setup */
667 	meson_venc_hdmi_mode_set(priv, vic, mode);
668 
669 	/* VCLK Set clock */
670 	dw_hdmi_set_vclk(dw_hdmi, mode);
671 
672 	/* Setup YUV444 to HDMI-TX, no 10bit diphering */
673 	writel_relaxed(0, priv->io_base + _REG(VPU_HDMI_FMT_CTRL));
674 }
675 
676 static const struct drm_encoder_helper_funcs
677 				meson_venc_hdmi_encoder_helper_funcs = {
678 	.atomic_check	= meson_venc_hdmi_encoder_atomic_check,
679 	.disable	= meson_venc_hdmi_encoder_disable,
680 	.enable		= meson_venc_hdmi_encoder_enable,
681 	.mode_set	= meson_venc_hdmi_encoder_mode_set,
682 };
683 
684 /* DW HDMI Regmap */
685 
686 static int meson_dw_hdmi_reg_read(void *context, unsigned int reg,
687 				  unsigned int *result)
688 {
689 	*result = dw_hdmi_dwc_read(context, reg);
690 
691 	return 0;
692 
693 }
694 
695 static int meson_dw_hdmi_reg_write(void *context, unsigned int reg,
696 				   unsigned int val)
697 {
698 	dw_hdmi_dwc_write(context, reg, val);
699 
700 	return 0;
701 }
702 
703 static const struct regmap_config meson_dw_hdmi_regmap_config = {
704 	.reg_bits = 32,
705 	.val_bits = 8,
706 	.reg_read = meson_dw_hdmi_reg_read,
707 	.reg_write = meson_dw_hdmi_reg_write,
708 	.max_register = 0x10000,
709 };
710 
711 static bool meson_hdmi_connector_is_available(struct device *dev)
712 {
713 	struct device_node *ep, *remote;
714 
715 	/* HDMI Connector is on the second port, first endpoint */
716 	ep = of_graph_get_endpoint_by_regs(dev->of_node, 1, 0);
717 	if (!ep)
718 		return false;
719 
720 	/* If the endpoint node exists, consider it enabled */
721 	remote = of_graph_get_remote_port(ep);
722 	if (remote) {
723 		of_node_put(ep);
724 		return true;
725 	}
726 
727 	of_node_put(ep);
728 	of_node_put(remote);
729 
730 	return false;
731 }
732 
733 static int meson_dw_hdmi_bind(struct device *dev, struct device *master,
734 				void *data)
735 {
736 	struct platform_device *pdev = to_platform_device(dev);
737 	struct meson_dw_hdmi *meson_dw_hdmi;
738 	struct drm_device *drm = data;
739 	struct meson_drm *priv = drm->dev_private;
740 	struct dw_hdmi_plat_data *dw_plat_data;
741 	struct drm_encoder *encoder;
742 	struct resource *res;
743 	int irq;
744 	int ret;
745 
746 	DRM_DEBUG_DRIVER("\n");
747 
748 	if (!meson_hdmi_connector_is_available(dev)) {
749 		dev_info(drm->dev, "HDMI Output connector not available\n");
750 		return -ENODEV;
751 	}
752 
753 	meson_dw_hdmi = devm_kzalloc(dev, sizeof(*meson_dw_hdmi),
754 				     GFP_KERNEL);
755 	if (!meson_dw_hdmi)
756 		return -ENOMEM;
757 
758 	meson_dw_hdmi->priv = priv;
759 	meson_dw_hdmi->dev = dev;
760 	dw_plat_data = &meson_dw_hdmi->dw_plat_data;
761 	encoder = &meson_dw_hdmi->encoder;
762 
763 	meson_dw_hdmi->hdmi_supply = devm_regulator_get_optional(dev, "hdmi");
764 	if (IS_ERR(meson_dw_hdmi->hdmi_supply)) {
765 		if (PTR_ERR(meson_dw_hdmi->hdmi_supply) == -EPROBE_DEFER)
766 			return -EPROBE_DEFER;
767 		meson_dw_hdmi->hdmi_supply = NULL;
768 	} else {
769 		ret = regulator_enable(meson_dw_hdmi->hdmi_supply);
770 		if (ret)
771 			return ret;
772 	}
773 
774 	meson_dw_hdmi->hdmitx_apb = devm_reset_control_get_exclusive(dev,
775 						"hdmitx_apb");
776 	if (IS_ERR(meson_dw_hdmi->hdmitx_apb)) {
777 		dev_err(dev, "Failed to get hdmitx_apb reset\n");
778 		return PTR_ERR(meson_dw_hdmi->hdmitx_apb);
779 	}
780 
781 	meson_dw_hdmi->hdmitx_ctrl = devm_reset_control_get_exclusive(dev,
782 						"hdmitx");
783 	if (IS_ERR(meson_dw_hdmi->hdmitx_ctrl)) {
784 		dev_err(dev, "Failed to get hdmitx reset\n");
785 		return PTR_ERR(meson_dw_hdmi->hdmitx_ctrl);
786 	}
787 
788 	meson_dw_hdmi->hdmitx_phy = devm_reset_control_get_exclusive(dev,
789 						"hdmitx_phy");
790 	if (IS_ERR(meson_dw_hdmi->hdmitx_phy)) {
791 		dev_err(dev, "Failed to get hdmitx_phy reset\n");
792 		return PTR_ERR(meson_dw_hdmi->hdmitx_phy);
793 	}
794 
795 	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
796 	meson_dw_hdmi->hdmitx = devm_ioremap_resource(dev, res);
797 	if (IS_ERR(meson_dw_hdmi->hdmitx))
798 		return PTR_ERR(meson_dw_hdmi->hdmitx);
799 
800 	meson_dw_hdmi->hdmi_pclk = devm_clk_get(dev, "isfr");
801 	if (IS_ERR(meson_dw_hdmi->hdmi_pclk)) {
802 		dev_err(dev, "Unable to get HDMI pclk\n");
803 		return PTR_ERR(meson_dw_hdmi->hdmi_pclk);
804 	}
805 	clk_prepare_enable(meson_dw_hdmi->hdmi_pclk);
806 
807 	meson_dw_hdmi->venci_clk = devm_clk_get(dev, "venci");
808 	if (IS_ERR(meson_dw_hdmi->venci_clk)) {
809 		dev_err(dev, "Unable to get venci clk\n");
810 		return PTR_ERR(meson_dw_hdmi->venci_clk);
811 	}
812 	clk_prepare_enable(meson_dw_hdmi->venci_clk);
813 
814 	dw_plat_data->regm = devm_regmap_init(dev, NULL, meson_dw_hdmi,
815 					      &meson_dw_hdmi_regmap_config);
816 	if (IS_ERR(dw_plat_data->regm))
817 		return PTR_ERR(dw_plat_data->regm);
818 
819 	irq = platform_get_irq(pdev, 0);
820 	if (irq < 0) {
821 		dev_err(dev, "Failed to get hdmi top irq\n");
822 		return irq;
823 	}
824 
825 	ret = devm_request_threaded_irq(dev, irq, dw_hdmi_top_irq,
826 					dw_hdmi_top_thread_irq, IRQF_SHARED,
827 					"dw_hdmi_top_irq", meson_dw_hdmi);
828 	if (ret) {
829 		dev_err(dev, "Failed to request hdmi top irq\n");
830 		return ret;
831 	}
832 
833 	/* Encoder */
834 
835 	drm_encoder_helper_add(encoder, &meson_venc_hdmi_encoder_helper_funcs);
836 
837 	ret = drm_encoder_init(drm, encoder, &meson_venc_hdmi_encoder_funcs,
838 			       DRM_MODE_ENCODER_TMDS, "meson_hdmi");
839 	if (ret) {
840 		dev_err(priv->dev, "Failed to init HDMI encoder\n");
841 		return ret;
842 	}
843 
844 	encoder->possible_crtcs = BIT(0);
845 
846 	DRM_DEBUG_DRIVER("encoder initialized\n");
847 
848 	/* Enable clocks */
849 	regmap_update_bits(priv->hhi, HHI_HDMI_CLK_CNTL, 0xffff, 0x100);
850 
851 	/* Bring HDMITX MEM output of power down */
852 	regmap_update_bits(priv->hhi, HHI_MEM_PD_REG0, 0xff << 8, 0);
853 
854 	/* Reset HDMITX APB & TX & PHY */
855 	reset_control_reset(meson_dw_hdmi->hdmitx_apb);
856 	reset_control_reset(meson_dw_hdmi->hdmitx_ctrl);
857 	reset_control_reset(meson_dw_hdmi->hdmitx_phy);
858 
859 	/* Enable APB3 fail on error */
860 	writel_bits_relaxed(BIT(15), BIT(15),
861 			    meson_dw_hdmi->hdmitx + HDMITX_TOP_CTRL_REG);
862 	writel_bits_relaxed(BIT(15), BIT(15),
863 			    meson_dw_hdmi->hdmitx + HDMITX_DWC_CTRL_REG);
864 
865 	/* Bring out of reset */
866 	dw_hdmi_top_write(meson_dw_hdmi, HDMITX_TOP_SW_RESET,  0);
867 
868 	msleep(20);
869 
870 	dw_hdmi_top_write(meson_dw_hdmi, HDMITX_TOP_CLK_CNTL, 0xff);
871 
872 	/* Enable HDMI-TX Interrupt */
873 	dw_hdmi_top_write(meson_dw_hdmi, HDMITX_TOP_INTR_STAT_CLR,
874 			  HDMITX_TOP_INTR_CORE);
875 
876 	dw_hdmi_top_write(meson_dw_hdmi, HDMITX_TOP_INTR_MASKN,
877 			  HDMITX_TOP_INTR_CORE);
878 
879 	/* Bridge / Connector */
880 
881 	dw_plat_data->mode_valid = dw_hdmi_mode_valid;
882 	dw_plat_data->phy_ops = &meson_dw_hdmi_phy_ops;
883 	dw_plat_data->phy_name = "meson_dw_hdmi_phy";
884 	dw_plat_data->phy_data = meson_dw_hdmi;
885 	dw_plat_data->input_bus_format = MEDIA_BUS_FMT_YUV8_1X24;
886 	dw_plat_data->input_bus_encoding = V4L2_YCBCR_ENC_709;
887 
888 	platform_set_drvdata(pdev, meson_dw_hdmi);
889 
890 	meson_dw_hdmi->hdmi = dw_hdmi_bind(pdev, encoder,
891 					   &meson_dw_hdmi->dw_plat_data);
892 	if (IS_ERR(meson_dw_hdmi->hdmi))
893 		return PTR_ERR(meson_dw_hdmi->hdmi);
894 
895 	DRM_DEBUG_DRIVER("HDMI controller initialized\n");
896 
897 	return 0;
898 }
899 
900 static void meson_dw_hdmi_unbind(struct device *dev, struct device *master,
901 				   void *data)
902 {
903 	struct meson_dw_hdmi *meson_dw_hdmi = dev_get_drvdata(dev);
904 
905 	dw_hdmi_unbind(meson_dw_hdmi->hdmi);
906 }
907 
908 static const struct component_ops meson_dw_hdmi_ops = {
909 	.bind	= meson_dw_hdmi_bind,
910 	.unbind	= meson_dw_hdmi_unbind,
911 };
912 
913 static int meson_dw_hdmi_probe(struct platform_device *pdev)
914 {
915 	return component_add(&pdev->dev, &meson_dw_hdmi_ops);
916 }
917 
918 static int meson_dw_hdmi_remove(struct platform_device *pdev)
919 {
920 	component_del(&pdev->dev, &meson_dw_hdmi_ops);
921 
922 	return 0;
923 }
924 
925 static const struct of_device_id meson_dw_hdmi_of_table[] = {
926 	{ .compatible = "amlogic,meson-gxbb-dw-hdmi" },
927 	{ .compatible = "amlogic,meson-gxl-dw-hdmi" },
928 	{ .compatible = "amlogic,meson-gxm-dw-hdmi" },
929 	{ }
930 };
931 MODULE_DEVICE_TABLE(of, meson_dw_hdmi_of_table);
932 
933 static struct platform_driver meson_dw_hdmi_platform_driver = {
934 	.probe		= meson_dw_hdmi_probe,
935 	.remove		= meson_dw_hdmi_remove,
936 	.driver		= {
937 		.name		= DRIVER_NAME,
938 		.of_match_table	= meson_dw_hdmi_of_table,
939 	},
940 };
941 module_platform_driver(meson_dw_hdmi_platform_driver);
942 
943 MODULE_AUTHOR("Neil Armstrong <narmstrong@baylibre.com>");
944 MODULE_DESCRIPTION(DRIVER_DESC);
945 MODULE_LICENSE("GPL");
946