xref: /openbmc/linux/drivers/gpu/drm/omapdrm/dss/hdmi4.c (revision c2807ecb)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * HDMI interface DSS driver for TI's OMAP4 family of SoCs.
4  *
5  * Copyright (C) 2010-2011 Texas Instruments Incorporated - https://www.ti.com/
6  * Authors: Yong Zhi
7  *	Mythri pk <mythripk@ti.com>
8  */
9 
10 #define DSS_SUBSYS_NAME "HDMI"
11 
12 #include <linux/kernel.h>
13 #include <linux/module.h>
14 #include <linux/err.h>
15 #include <linux/io.h>
16 #include <linux/interrupt.h>
17 #include <linux/mutex.h>
18 #include <linux/delay.h>
19 #include <linux/string.h>
20 #include <linux/platform_device.h>
21 #include <linux/pm_runtime.h>
22 #include <linux/clk.h>
23 #include <linux/regulator/consumer.h>
24 #include <linux/component.h>
25 #include <linux/of.h>
26 #include <linux/of_graph.h>
27 #include <sound/omap-hdmi-audio.h>
28 #include <media/cec.h>
29 
30 #include <drm/drm_atomic.h>
31 #include <drm/drm_atomic_state_helper.h>
32 #include <drm/drm_edid.h>
33 
34 #include "omapdss.h"
35 #include "hdmi4_core.h"
36 #include "hdmi4_cec.h"
37 #include "dss.h"
38 #include "hdmi.h"
39 
hdmi_runtime_get(struct omap_hdmi * hdmi)40 static int hdmi_runtime_get(struct omap_hdmi *hdmi)
41 {
42 	int r;
43 
44 	DSSDBG("hdmi_runtime_get\n");
45 
46 	r = pm_runtime_get_sync(&hdmi->pdev->dev);
47 	if (WARN_ON(r < 0)) {
48 		pm_runtime_put_noidle(&hdmi->pdev->dev);
49 		return r;
50 	}
51 	return 0;
52 }
53 
hdmi_runtime_put(struct omap_hdmi * hdmi)54 static void hdmi_runtime_put(struct omap_hdmi *hdmi)
55 {
56 	int r;
57 
58 	DSSDBG("hdmi_runtime_put\n");
59 
60 	r = pm_runtime_put_sync(&hdmi->pdev->dev);
61 	WARN_ON(r < 0 && r != -ENOSYS);
62 }
63 
hdmi_irq_handler(int irq,void * data)64 static irqreturn_t hdmi_irq_handler(int irq, void *data)
65 {
66 	struct omap_hdmi *hdmi = data;
67 	struct hdmi_wp_data *wp = &hdmi->wp;
68 	u32 irqstatus;
69 
70 	irqstatus = hdmi_wp_get_irqstatus(wp);
71 	hdmi_wp_set_irqstatus(wp, irqstatus);
72 
73 	if ((irqstatus & HDMI_IRQ_LINK_CONNECT) &&
74 			irqstatus & HDMI_IRQ_LINK_DISCONNECT) {
75 		/*
76 		 * If we get both connect and disconnect interrupts at the same
77 		 * time, turn off the PHY, clear interrupts, and restart, which
78 		 * raises connect interrupt if a cable is connected, or nothing
79 		 * if cable is not connected.
80 		 */
81 		hdmi_wp_set_phy_pwr(wp, HDMI_PHYPWRCMD_OFF);
82 
83 		hdmi_wp_set_irqstatus(wp, HDMI_IRQ_LINK_CONNECT |
84 				HDMI_IRQ_LINK_DISCONNECT);
85 
86 		hdmi_wp_set_phy_pwr(wp, HDMI_PHYPWRCMD_LDOON);
87 	} else if (irqstatus & HDMI_IRQ_LINK_CONNECT) {
88 		hdmi_wp_set_phy_pwr(wp, HDMI_PHYPWRCMD_TXON);
89 	} else if (irqstatus & HDMI_IRQ_LINK_DISCONNECT) {
90 		hdmi_wp_set_phy_pwr(wp, HDMI_PHYPWRCMD_LDOON);
91 	}
92 	if (irqstatus & HDMI_IRQ_CORE) {
93 		u32 intr4 = hdmi_read_reg(hdmi->core.base, HDMI_CORE_SYS_INTR4);
94 
95 		hdmi_write_reg(hdmi->core.base, HDMI_CORE_SYS_INTR4, intr4);
96 		if (intr4 & 8)
97 			hdmi4_cec_irq(&hdmi->core);
98 	}
99 
100 	return IRQ_HANDLED;
101 }
102 
hdmi_power_on_core(struct omap_hdmi * hdmi)103 static int hdmi_power_on_core(struct omap_hdmi *hdmi)
104 {
105 	int r;
106 
107 	if (hdmi->core.core_pwr_cnt++)
108 		return 0;
109 
110 	r = regulator_enable(hdmi->vdda_reg);
111 	if (r)
112 		goto err_reg_enable;
113 
114 	r = hdmi_runtime_get(hdmi);
115 	if (r)
116 		goto err_runtime_get;
117 
118 	hdmi4_core_powerdown_disable(&hdmi->core);
119 
120 	/* Make selection of HDMI in DSS */
121 	dss_select_hdmi_venc_clk_source(hdmi->dss, DSS_HDMI_M_PCLK);
122 
123 	hdmi->core_enabled = true;
124 
125 	return 0;
126 
127 err_runtime_get:
128 	regulator_disable(hdmi->vdda_reg);
129 err_reg_enable:
130 	hdmi->core.core_pwr_cnt--;
131 
132 	return r;
133 }
134 
hdmi_power_off_core(struct omap_hdmi * hdmi)135 static void hdmi_power_off_core(struct omap_hdmi *hdmi)
136 {
137 	if (--hdmi->core.core_pwr_cnt)
138 		return;
139 
140 	hdmi->core_enabled = false;
141 
142 	hdmi_runtime_put(hdmi);
143 	regulator_disable(hdmi->vdda_reg);
144 }
145 
hdmi_power_on_full(struct omap_hdmi * hdmi)146 static int hdmi_power_on_full(struct omap_hdmi *hdmi)
147 {
148 	int r;
149 	const struct videomode *vm;
150 	struct hdmi_wp_data *wp = &hdmi->wp;
151 	struct dss_pll_clock_info hdmi_cinfo = { 0 };
152 	unsigned int pc;
153 
154 	r = hdmi_power_on_core(hdmi);
155 	if (r)
156 		return r;
157 
158 	/* disable and clear irqs */
159 	hdmi_wp_clear_irqenable(wp, ~HDMI_IRQ_CORE);
160 	hdmi_wp_set_irqstatus(wp, ~HDMI_IRQ_CORE);
161 
162 	vm = &hdmi->cfg.vm;
163 
164 	DSSDBG("hdmi_power_on hactive= %d vactive = %d\n", vm->hactive,
165 	       vm->vactive);
166 
167 	pc = vm->pixelclock;
168 	if (vm->flags & DISPLAY_FLAGS_DOUBLECLK)
169 		pc *= 2;
170 
171 	/* DSS_HDMI_TCLK is bitclk / 10 */
172 	pc *= 10;
173 
174 	dss_pll_calc_b(&hdmi->pll.pll, clk_get_rate(hdmi->pll.pll.clkin),
175 		pc, &hdmi_cinfo);
176 
177 	r = dss_pll_enable(&hdmi->pll.pll);
178 	if (r) {
179 		DSSERR("Failed to enable PLL\n");
180 		goto err_pll_enable;
181 	}
182 
183 	r = dss_pll_set_config(&hdmi->pll.pll, &hdmi_cinfo);
184 	if (r) {
185 		DSSERR("Failed to configure PLL\n");
186 		goto err_pll_cfg;
187 	}
188 
189 	r = hdmi_phy_configure(&hdmi->phy, hdmi_cinfo.clkdco,
190 		hdmi_cinfo.clkout[0]);
191 	if (r) {
192 		DSSDBG("Failed to configure PHY\n");
193 		goto err_phy_cfg;
194 	}
195 
196 	r = hdmi_wp_set_phy_pwr(wp, HDMI_PHYPWRCMD_LDOON);
197 	if (r)
198 		goto err_phy_pwr;
199 
200 	hdmi4_configure(&hdmi->core, &hdmi->wp, &hdmi->cfg);
201 
202 	r = dss_mgr_enable(&hdmi->output);
203 	if (r)
204 		goto err_mgr_enable;
205 
206 	r = hdmi_wp_video_start(&hdmi->wp);
207 	if (r)
208 		goto err_vid_enable;
209 
210 	hdmi_wp_set_irqenable(wp,
211 		HDMI_IRQ_LINK_CONNECT | HDMI_IRQ_LINK_DISCONNECT);
212 
213 	return 0;
214 
215 err_vid_enable:
216 	dss_mgr_disable(&hdmi->output);
217 err_mgr_enable:
218 	hdmi_wp_set_phy_pwr(&hdmi->wp, HDMI_PHYPWRCMD_OFF);
219 err_phy_pwr:
220 err_phy_cfg:
221 err_pll_cfg:
222 	dss_pll_disable(&hdmi->pll.pll);
223 err_pll_enable:
224 	hdmi_power_off_core(hdmi);
225 	return -EIO;
226 }
227 
hdmi_power_off_full(struct omap_hdmi * hdmi)228 static void hdmi_power_off_full(struct omap_hdmi *hdmi)
229 {
230 	hdmi_wp_clear_irqenable(&hdmi->wp, ~HDMI_IRQ_CORE);
231 
232 	hdmi_wp_video_stop(&hdmi->wp);
233 
234 	dss_mgr_disable(&hdmi->output);
235 
236 	hdmi_wp_set_phy_pwr(&hdmi->wp, HDMI_PHYPWRCMD_OFF);
237 
238 	dss_pll_disable(&hdmi->pll.pll);
239 
240 	hdmi_power_off_core(hdmi);
241 }
242 
hdmi_dump_regs(struct seq_file * s,void * p)243 static int hdmi_dump_regs(struct seq_file *s, void *p)
244 {
245 	struct omap_hdmi *hdmi = s->private;
246 
247 	mutex_lock(&hdmi->lock);
248 
249 	if (hdmi_runtime_get(hdmi)) {
250 		mutex_unlock(&hdmi->lock);
251 		return 0;
252 	}
253 
254 	hdmi_wp_dump(&hdmi->wp, s);
255 	hdmi_pll_dump(&hdmi->pll, s);
256 	hdmi_phy_dump(&hdmi->phy, s);
257 	hdmi4_core_dump(&hdmi->core, s);
258 
259 	hdmi_runtime_put(hdmi);
260 	mutex_unlock(&hdmi->lock);
261 	return 0;
262 }
263 
hdmi_start_audio_stream(struct omap_hdmi * hd)264 static void hdmi_start_audio_stream(struct omap_hdmi *hd)
265 {
266 	hdmi_wp_audio_enable(&hd->wp, true);
267 	hdmi4_audio_start(&hd->core, &hd->wp);
268 }
269 
hdmi_stop_audio_stream(struct omap_hdmi * hd)270 static void hdmi_stop_audio_stream(struct omap_hdmi *hd)
271 {
272 	hdmi4_audio_stop(&hd->core, &hd->wp);
273 	hdmi_wp_audio_enable(&hd->wp, false);
274 }
275 
hdmi4_core_enable(struct hdmi_core_data * core)276 int hdmi4_core_enable(struct hdmi_core_data *core)
277 {
278 	struct omap_hdmi *hdmi = container_of(core, struct omap_hdmi, core);
279 	int r = 0;
280 
281 	DSSDBG("ENTER omapdss_hdmi4_core_enable\n");
282 
283 	mutex_lock(&hdmi->lock);
284 
285 	r = hdmi_power_on_core(hdmi);
286 	if (r) {
287 		DSSERR("failed to power on device\n");
288 		goto err0;
289 	}
290 
291 	mutex_unlock(&hdmi->lock);
292 	return 0;
293 
294 err0:
295 	mutex_unlock(&hdmi->lock);
296 	return r;
297 }
298 
hdmi4_core_disable(struct hdmi_core_data * core)299 void hdmi4_core_disable(struct hdmi_core_data *core)
300 {
301 	struct omap_hdmi *hdmi = container_of(core, struct omap_hdmi, core);
302 
303 	DSSDBG("Enter omapdss_hdmi4_core_disable\n");
304 
305 	mutex_lock(&hdmi->lock);
306 
307 	hdmi_power_off_core(hdmi);
308 
309 	mutex_unlock(&hdmi->lock);
310 }
311 
312 /* -----------------------------------------------------------------------------
313  * DRM Bridge Operations
314  */
315 
hdmi4_bridge_attach(struct drm_bridge * bridge,enum drm_bridge_attach_flags flags)316 static int hdmi4_bridge_attach(struct drm_bridge *bridge,
317 			       enum drm_bridge_attach_flags flags)
318 {
319 	struct omap_hdmi *hdmi = drm_bridge_to_hdmi(bridge);
320 
321 	if (!(flags & DRM_BRIDGE_ATTACH_NO_CONNECTOR))
322 		return -EINVAL;
323 
324 	return drm_bridge_attach(bridge->encoder, hdmi->output.next_bridge,
325 				 bridge, flags);
326 }
327 
hdmi4_bridge_mode_set(struct drm_bridge * bridge,const struct drm_display_mode * mode,const struct drm_display_mode * adjusted_mode)328 static void hdmi4_bridge_mode_set(struct drm_bridge *bridge,
329 				  const struct drm_display_mode *mode,
330 				  const struct drm_display_mode *adjusted_mode)
331 {
332 	struct omap_hdmi *hdmi = drm_bridge_to_hdmi(bridge);
333 
334 	mutex_lock(&hdmi->lock);
335 
336 	drm_display_mode_to_videomode(adjusted_mode, &hdmi->cfg.vm);
337 
338 	dispc_set_tv_pclk(hdmi->dss->dispc, adjusted_mode->clock * 1000);
339 
340 	mutex_unlock(&hdmi->lock);
341 }
342 
hdmi4_bridge_enable(struct drm_bridge * bridge,struct drm_bridge_state * bridge_state)343 static void hdmi4_bridge_enable(struct drm_bridge *bridge,
344 				struct drm_bridge_state *bridge_state)
345 {
346 	struct omap_hdmi *hdmi = drm_bridge_to_hdmi(bridge);
347 	struct drm_atomic_state *state = bridge_state->base.state;
348 	struct drm_connector_state *conn_state;
349 	struct drm_connector *connector;
350 	struct drm_crtc_state *crtc_state;
351 	unsigned long flags;
352 	int ret;
353 
354 	/*
355 	 * None of these should fail, as the bridge can't be enabled without a
356 	 * valid CRTC to connector path with fully populated new states.
357 	 */
358 	connector = drm_atomic_get_new_connector_for_encoder(state,
359 							     bridge->encoder);
360 	if (WARN_ON(!connector))
361 		return;
362 	conn_state = drm_atomic_get_new_connector_state(state, connector);
363 	if (WARN_ON(!conn_state))
364 		return;
365 	crtc_state = drm_atomic_get_new_crtc_state(state, conn_state->crtc);
366 	if (WARN_ON(!crtc_state))
367 		return;
368 
369 	hdmi->cfg.hdmi_dvi_mode = connector->display_info.is_hdmi
370 				? HDMI_HDMI : HDMI_DVI;
371 
372 	if (connector->display_info.is_hdmi) {
373 		const struct drm_display_mode *mode;
374 		struct hdmi_avi_infoframe avi;
375 
376 		mode = &crtc_state->adjusted_mode;
377 		ret = drm_hdmi_avi_infoframe_from_display_mode(&avi, connector,
378 							       mode);
379 		if (ret == 0)
380 			hdmi->cfg.infoframe = avi;
381 	}
382 
383 	mutex_lock(&hdmi->lock);
384 
385 	ret = hdmi_power_on_full(hdmi);
386 	if (ret) {
387 		DSSERR("failed to power on device\n");
388 		goto done;
389 	}
390 
391 	if (hdmi->audio_configured) {
392 		ret = hdmi4_audio_config(&hdmi->core, &hdmi->wp,
393 					 &hdmi->audio_config,
394 					 hdmi->cfg.vm.pixelclock);
395 		if (ret) {
396 			DSSERR("Error restoring audio configuration: %d", ret);
397 			hdmi->audio_abort_cb(&hdmi->pdev->dev);
398 			hdmi->audio_configured = false;
399 		}
400 	}
401 
402 	spin_lock_irqsave(&hdmi->audio_playing_lock, flags);
403 	if (hdmi->audio_configured && hdmi->audio_playing)
404 		hdmi_start_audio_stream(hdmi);
405 	hdmi->display_enabled = true;
406 	spin_unlock_irqrestore(&hdmi->audio_playing_lock, flags);
407 
408 done:
409 	mutex_unlock(&hdmi->lock);
410 }
411 
hdmi4_bridge_disable(struct drm_bridge * bridge,struct drm_bridge_state * bridge_state)412 static void hdmi4_bridge_disable(struct drm_bridge *bridge,
413 				 struct drm_bridge_state *bridge_state)
414 {
415 	struct omap_hdmi *hdmi = drm_bridge_to_hdmi(bridge);
416 	unsigned long flags;
417 
418 	mutex_lock(&hdmi->lock);
419 
420 	spin_lock_irqsave(&hdmi->audio_playing_lock, flags);
421 	hdmi_stop_audio_stream(hdmi);
422 	hdmi->display_enabled = false;
423 	spin_unlock_irqrestore(&hdmi->audio_playing_lock, flags);
424 
425 	hdmi_power_off_full(hdmi);
426 
427 	mutex_unlock(&hdmi->lock);
428 }
429 
hdmi4_bridge_hpd_notify(struct drm_bridge * bridge,enum drm_connector_status status)430 static void hdmi4_bridge_hpd_notify(struct drm_bridge *bridge,
431 				    enum drm_connector_status status)
432 {
433 	struct omap_hdmi *hdmi = drm_bridge_to_hdmi(bridge);
434 
435 	if (status == connector_status_disconnected)
436 		hdmi4_cec_set_phys_addr(&hdmi->core, CEC_PHYS_ADDR_INVALID);
437 }
438 
hdmi4_bridge_get_edid(struct drm_bridge * bridge,struct drm_connector * connector)439 static struct edid *hdmi4_bridge_get_edid(struct drm_bridge *bridge,
440 					  struct drm_connector *connector)
441 {
442 	struct omap_hdmi *hdmi = drm_bridge_to_hdmi(bridge);
443 	struct edid *edid = NULL;
444 	unsigned int cec_addr;
445 	bool need_enable;
446 	int r;
447 
448 	need_enable = hdmi->core_enabled == false;
449 
450 	if (need_enable) {
451 		r = hdmi4_core_enable(&hdmi->core);
452 		if (r)
453 			return NULL;
454 	}
455 
456 	mutex_lock(&hdmi->lock);
457 	r = hdmi_runtime_get(hdmi);
458 	BUG_ON(r);
459 
460 	r = hdmi4_core_ddc_init(&hdmi->core);
461 	if (r)
462 		goto done;
463 
464 	edid = drm_do_get_edid(connector, hdmi4_core_ddc_read, &hdmi->core);
465 
466 done:
467 	hdmi_runtime_put(hdmi);
468 	mutex_unlock(&hdmi->lock);
469 
470 	if (edid && edid->extensions) {
471 		unsigned int len = (edid->extensions + 1) * EDID_LENGTH;
472 
473 		cec_addr = cec_get_edid_phys_addr((u8 *)edid, len, NULL);
474 	} else {
475 		cec_addr = CEC_PHYS_ADDR_INVALID;
476 	}
477 
478 	hdmi4_cec_set_phys_addr(&hdmi->core, cec_addr);
479 
480 	if (need_enable)
481 		hdmi4_core_disable(&hdmi->core);
482 
483 	return edid;
484 }
485 
486 static const struct drm_bridge_funcs hdmi4_bridge_funcs = {
487 	.attach = hdmi4_bridge_attach,
488 	.mode_set = hdmi4_bridge_mode_set,
489 	.atomic_duplicate_state = drm_atomic_helper_bridge_duplicate_state,
490 	.atomic_destroy_state = drm_atomic_helper_bridge_destroy_state,
491 	.atomic_reset = drm_atomic_helper_bridge_reset,
492 	.atomic_enable = hdmi4_bridge_enable,
493 	.atomic_disable = hdmi4_bridge_disable,
494 	.hpd_notify = hdmi4_bridge_hpd_notify,
495 	.get_edid = hdmi4_bridge_get_edid,
496 };
497 
hdmi4_bridge_init(struct omap_hdmi * hdmi)498 static void hdmi4_bridge_init(struct omap_hdmi *hdmi)
499 {
500 	hdmi->bridge.funcs = &hdmi4_bridge_funcs;
501 	hdmi->bridge.of_node = hdmi->pdev->dev.of_node;
502 	hdmi->bridge.ops = DRM_BRIDGE_OP_EDID;
503 	hdmi->bridge.type = DRM_MODE_CONNECTOR_HDMIA;
504 
505 	drm_bridge_add(&hdmi->bridge);
506 }
507 
hdmi4_bridge_cleanup(struct omap_hdmi * hdmi)508 static void hdmi4_bridge_cleanup(struct omap_hdmi *hdmi)
509 {
510 	drm_bridge_remove(&hdmi->bridge);
511 }
512 
513 /* -----------------------------------------------------------------------------
514  * Audio Callbacks
515  */
516 
hdmi_audio_startup(struct device * dev,void (* abort_cb)(struct device * dev))517 static int hdmi_audio_startup(struct device *dev,
518 			      void (*abort_cb)(struct device *dev))
519 {
520 	struct omap_hdmi *hd = dev_get_drvdata(dev);
521 
522 	mutex_lock(&hd->lock);
523 
524 	WARN_ON(hd->audio_abort_cb != NULL);
525 
526 	hd->audio_abort_cb = abort_cb;
527 
528 	mutex_unlock(&hd->lock);
529 
530 	return 0;
531 }
532 
hdmi_audio_shutdown(struct device * dev)533 static int hdmi_audio_shutdown(struct device *dev)
534 {
535 	struct omap_hdmi *hd = dev_get_drvdata(dev);
536 
537 	mutex_lock(&hd->lock);
538 	hd->audio_abort_cb = NULL;
539 	hd->audio_configured = false;
540 	hd->audio_playing = false;
541 	mutex_unlock(&hd->lock);
542 
543 	return 0;
544 }
545 
hdmi_audio_start(struct device * dev)546 static int hdmi_audio_start(struct device *dev)
547 {
548 	struct omap_hdmi *hd = dev_get_drvdata(dev);
549 	unsigned long flags;
550 
551 	spin_lock_irqsave(&hd->audio_playing_lock, flags);
552 
553 	if (hd->display_enabled) {
554 		if (!hdmi_mode_has_audio(&hd->cfg))
555 			DSSERR("%s: Video mode does not support audio\n",
556 			       __func__);
557 		hdmi_start_audio_stream(hd);
558 	}
559 	hd->audio_playing = true;
560 
561 	spin_unlock_irqrestore(&hd->audio_playing_lock, flags);
562 	return 0;
563 }
564 
hdmi_audio_stop(struct device * dev)565 static void hdmi_audio_stop(struct device *dev)
566 {
567 	struct omap_hdmi *hd = dev_get_drvdata(dev);
568 	unsigned long flags;
569 
570 	WARN_ON(!hdmi_mode_has_audio(&hd->cfg));
571 
572 	spin_lock_irqsave(&hd->audio_playing_lock, flags);
573 
574 	if (hd->display_enabled)
575 		hdmi_stop_audio_stream(hd);
576 	hd->audio_playing = false;
577 
578 	spin_unlock_irqrestore(&hd->audio_playing_lock, flags);
579 }
580 
hdmi_audio_config(struct device * dev,struct omap_dss_audio * dss_audio)581 static int hdmi_audio_config(struct device *dev,
582 			     struct omap_dss_audio *dss_audio)
583 {
584 	struct omap_hdmi *hd = dev_get_drvdata(dev);
585 	int ret = 0;
586 
587 	mutex_lock(&hd->lock);
588 
589 	if (hd->display_enabled) {
590 		ret = hdmi4_audio_config(&hd->core, &hd->wp, dss_audio,
591 					 hd->cfg.vm.pixelclock);
592 		if (ret)
593 			goto out;
594 	}
595 
596 	hd->audio_configured = true;
597 	hd->audio_config = *dss_audio;
598 out:
599 	mutex_unlock(&hd->lock);
600 
601 	return ret;
602 }
603 
604 static const struct omap_hdmi_audio_ops hdmi_audio_ops = {
605 	.audio_startup = hdmi_audio_startup,
606 	.audio_shutdown = hdmi_audio_shutdown,
607 	.audio_start = hdmi_audio_start,
608 	.audio_stop = hdmi_audio_stop,
609 	.audio_config = hdmi_audio_config,
610 };
611 
hdmi_audio_register(struct omap_hdmi * hdmi)612 static int hdmi_audio_register(struct omap_hdmi *hdmi)
613 {
614 	struct omap_hdmi_audio_pdata pdata = {
615 		.dev = &hdmi->pdev->dev,
616 		.version = 4,
617 		.audio_dma_addr = hdmi_wp_get_audio_dma_addr(&hdmi->wp),
618 		.ops = &hdmi_audio_ops,
619 	};
620 
621 	hdmi->audio_pdev = platform_device_register_data(
622 		&hdmi->pdev->dev, "omap-hdmi-audio", PLATFORM_DEVID_AUTO,
623 		&pdata, sizeof(pdata));
624 
625 	if (IS_ERR(hdmi->audio_pdev))
626 		return PTR_ERR(hdmi->audio_pdev);
627 
628 	return 0;
629 }
630 
631 /* -----------------------------------------------------------------------------
632  * Component Bind & Unbind
633  */
634 
hdmi4_bind(struct device * dev,struct device * master,void * data)635 static int hdmi4_bind(struct device *dev, struct device *master, void *data)
636 {
637 	struct dss_device *dss = dss_get_device(master);
638 	struct omap_hdmi *hdmi = dev_get_drvdata(dev);
639 	int r;
640 
641 	hdmi->dss = dss;
642 
643 	r = hdmi_runtime_get(hdmi);
644 	if (r)
645 		return r;
646 
647 	r = hdmi_pll_init(dss, hdmi->pdev, &hdmi->pll, &hdmi->wp);
648 	if (r)
649 		goto err_runtime_put;
650 
651 	r = hdmi4_cec_init(hdmi->pdev, &hdmi->core, &hdmi->wp);
652 	if (r)
653 		goto err_pll_uninit;
654 
655 	r = hdmi_audio_register(hdmi);
656 	if (r) {
657 		DSSERR("Registering HDMI audio failed\n");
658 		goto err_cec_uninit;
659 	}
660 
661 	hdmi->debugfs = dss_debugfs_create_file(dss, "hdmi", hdmi_dump_regs,
662 					       hdmi);
663 
664 	hdmi_runtime_put(hdmi);
665 
666 	return 0;
667 
668 err_cec_uninit:
669 	hdmi4_cec_uninit(&hdmi->core);
670 err_pll_uninit:
671 	hdmi_pll_uninit(&hdmi->pll);
672 err_runtime_put:
673 	hdmi_runtime_put(hdmi);
674 	return r;
675 }
676 
hdmi4_unbind(struct device * dev,struct device * master,void * data)677 static void hdmi4_unbind(struct device *dev, struct device *master, void *data)
678 {
679 	struct omap_hdmi *hdmi = dev_get_drvdata(dev);
680 
681 	dss_debugfs_remove_file(hdmi->debugfs);
682 
683 	if (hdmi->audio_pdev)
684 		platform_device_unregister(hdmi->audio_pdev);
685 
686 	hdmi4_cec_uninit(&hdmi->core);
687 	hdmi_pll_uninit(&hdmi->pll);
688 }
689 
690 static const struct component_ops hdmi4_component_ops = {
691 	.bind	= hdmi4_bind,
692 	.unbind	= hdmi4_unbind,
693 };
694 
695 /* -----------------------------------------------------------------------------
696  * Probe & Remove, Suspend & Resume
697  */
698 
hdmi4_init_output(struct omap_hdmi * hdmi)699 static int hdmi4_init_output(struct omap_hdmi *hdmi)
700 {
701 	struct omap_dss_device *out = &hdmi->output;
702 	int r;
703 
704 	hdmi4_bridge_init(hdmi);
705 
706 	out->dev = &hdmi->pdev->dev;
707 	out->id = OMAP_DSS_OUTPUT_HDMI;
708 	out->type = OMAP_DISPLAY_TYPE_HDMI;
709 	out->name = "hdmi.0";
710 	out->dispc_channel = OMAP_DSS_CHANNEL_DIGIT;
711 	out->of_port = 0;
712 
713 	r = omapdss_device_init_output(out, &hdmi->bridge);
714 	if (r < 0) {
715 		hdmi4_bridge_cleanup(hdmi);
716 		return r;
717 	}
718 
719 	omapdss_device_register(out);
720 
721 	return 0;
722 }
723 
hdmi4_uninit_output(struct omap_hdmi * hdmi)724 static void hdmi4_uninit_output(struct omap_hdmi *hdmi)
725 {
726 	struct omap_dss_device *out = &hdmi->output;
727 
728 	omapdss_device_unregister(out);
729 	omapdss_device_cleanup_output(out);
730 
731 	hdmi4_bridge_cleanup(hdmi);
732 }
733 
hdmi4_probe_of(struct omap_hdmi * hdmi)734 static int hdmi4_probe_of(struct omap_hdmi *hdmi)
735 {
736 	struct platform_device *pdev = hdmi->pdev;
737 	struct device_node *node = pdev->dev.of_node;
738 	struct device_node *ep;
739 	int r;
740 
741 	ep = of_graph_get_endpoint_by_regs(node, 0, 0);
742 	if (!ep)
743 		return 0;
744 
745 	r = hdmi_parse_lanes_of(pdev, ep, &hdmi->phy);
746 	of_node_put(ep);
747 	return r;
748 }
749 
hdmi4_probe(struct platform_device * pdev)750 static int hdmi4_probe(struct platform_device *pdev)
751 {
752 	struct omap_hdmi *hdmi;
753 	int irq;
754 	int r;
755 
756 	hdmi = kzalloc(sizeof(*hdmi), GFP_KERNEL);
757 	if (!hdmi)
758 		return -ENOMEM;
759 
760 	hdmi->pdev = pdev;
761 
762 	dev_set_drvdata(&pdev->dev, hdmi);
763 
764 	mutex_init(&hdmi->lock);
765 	spin_lock_init(&hdmi->audio_playing_lock);
766 
767 	r = hdmi4_probe_of(hdmi);
768 	if (r)
769 		goto err_free;
770 
771 	r = hdmi_wp_init(pdev, &hdmi->wp, 4);
772 	if (r)
773 		goto err_free;
774 
775 	r = hdmi_phy_init(pdev, &hdmi->phy, 4);
776 	if (r)
777 		goto err_free;
778 
779 	r = hdmi4_core_init(pdev, &hdmi->core);
780 	if (r)
781 		goto err_free;
782 
783 	irq = platform_get_irq(pdev, 0);
784 	if (irq < 0) {
785 		DSSERR("platform_get_irq failed\n");
786 		r = -ENODEV;
787 		goto err_free;
788 	}
789 
790 	r = devm_request_threaded_irq(&pdev->dev, irq,
791 			NULL, hdmi_irq_handler,
792 			IRQF_ONESHOT, "OMAP HDMI", hdmi);
793 	if (r) {
794 		DSSERR("HDMI IRQ request failed\n");
795 		goto err_free;
796 	}
797 
798 	hdmi->vdda_reg = devm_regulator_get(&pdev->dev, "vdda");
799 	if (IS_ERR(hdmi->vdda_reg)) {
800 		r = PTR_ERR(hdmi->vdda_reg);
801 		if (r != -EPROBE_DEFER)
802 			DSSERR("can't get VDDA regulator\n");
803 		goto err_free;
804 	}
805 
806 	pm_runtime_enable(&pdev->dev);
807 
808 	r = hdmi4_init_output(hdmi);
809 	if (r)
810 		goto err_pm_disable;
811 
812 	r = component_add(&pdev->dev, &hdmi4_component_ops);
813 	if (r)
814 		goto err_uninit_output;
815 
816 	return 0;
817 
818 err_uninit_output:
819 	hdmi4_uninit_output(hdmi);
820 err_pm_disable:
821 	pm_runtime_disable(&pdev->dev);
822 err_free:
823 	kfree(hdmi);
824 	return r;
825 }
826 
hdmi4_remove(struct platform_device * pdev)827 static void hdmi4_remove(struct platform_device *pdev)
828 {
829 	struct omap_hdmi *hdmi = platform_get_drvdata(pdev);
830 
831 	component_del(&pdev->dev, &hdmi4_component_ops);
832 
833 	hdmi4_uninit_output(hdmi);
834 
835 	pm_runtime_disable(&pdev->dev);
836 
837 	kfree(hdmi);
838 }
839 
840 static const struct of_device_id hdmi_of_match[] = {
841 	{ .compatible = "ti,omap4-hdmi", },
842 	{},
843 };
844 
845 struct platform_driver omapdss_hdmi4hw_driver = {
846 	.probe		= hdmi4_probe,
847 	.remove_new	= hdmi4_remove,
848 	.driver         = {
849 		.name   = "omapdss_hdmi",
850 		.of_match_table = hdmi_of_match,
851 		.suppress_bind_attrs = true,
852 	},
853 };
854