1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * HDMI interface DSS driver for TI's OMAP4 family of SoCs.
4  * Copyright (C) 2010-2011 Texas Instruments Incorporated - http://www.ti.com/
5  * Authors: Yong Zhi
6  *	Mythri pk <mythripk@ti.com>
7  */
8 
9 #define DSS_SUBSYS_NAME "HDMI"
10 
11 #include <linux/kernel.h>
12 #include <linux/module.h>
13 #include <linux/err.h>
14 #include <linux/io.h>
15 #include <linux/interrupt.h>
16 #include <linux/mutex.h>
17 #include <linux/delay.h>
18 #include <linux/string.h>
19 #include <linux/platform_device.h>
20 #include <linux/pm_runtime.h>
21 #include <linux/clk.h>
22 #include <linux/gpio.h>
23 #include <linux/regulator/consumer.h>
24 #include <linux/component.h>
25 #include <video/omapfb_dss.h>
26 #include <sound/omap-hdmi-audio.h>
27 
28 #include "hdmi4_core.h"
29 #include "dss.h"
30 #include "dss_features.h"
31 #include "hdmi.h"
32 
33 static struct omap_hdmi hdmi;
34 
35 static int hdmi_runtime_get(void)
36 {
37 	int r;
38 
39 	DSSDBG("hdmi_runtime_get\n");
40 
41 	r = pm_runtime_get_sync(&hdmi.pdev->dev);
42 	WARN_ON(r < 0);
43 	if (r < 0)
44 		return r;
45 
46 	return 0;
47 }
48 
49 static void hdmi_runtime_put(void)
50 {
51 	int r;
52 
53 	DSSDBG("hdmi_runtime_put\n");
54 
55 	r = pm_runtime_put_sync(&hdmi.pdev->dev);
56 	WARN_ON(r < 0 && r != -ENOSYS);
57 }
58 
59 static irqreturn_t hdmi_irq_handler(int irq, void *data)
60 {
61 	struct hdmi_wp_data *wp = data;
62 	u32 irqstatus;
63 
64 	irqstatus = hdmi_wp_get_irqstatus(wp);
65 	hdmi_wp_set_irqstatus(wp, irqstatus);
66 
67 	if ((irqstatus & HDMI_IRQ_LINK_CONNECT) &&
68 			irqstatus & HDMI_IRQ_LINK_DISCONNECT) {
69 		/*
70 		 * If we get both connect and disconnect interrupts at the same
71 		 * time, turn off the PHY, clear interrupts, and restart, which
72 		 * raises connect interrupt if a cable is connected, or nothing
73 		 * if cable is not connected.
74 		 */
75 		hdmi_wp_set_phy_pwr(wp, HDMI_PHYPWRCMD_OFF);
76 
77 		hdmi_wp_set_irqstatus(wp, HDMI_IRQ_LINK_CONNECT |
78 				HDMI_IRQ_LINK_DISCONNECT);
79 
80 		hdmi_wp_set_phy_pwr(wp, HDMI_PHYPWRCMD_LDOON);
81 	} else if (irqstatus & HDMI_IRQ_LINK_CONNECT) {
82 		hdmi_wp_set_phy_pwr(wp, HDMI_PHYPWRCMD_TXON);
83 	} else if (irqstatus & HDMI_IRQ_LINK_DISCONNECT) {
84 		hdmi_wp_set_phy_pwr(wp, HDMI_PHYPWRCMD_LDOON);
85 	}
86 
87 	return IRQ_HANDLED;
88 }
89 
90 static int hdmi_init_regulator(void)
91 {
92 	struct regulator *reg;
93 
94 	if (hdmi.vdda_reg != NULL)
95 		return 0;
96 
97 	reg = devm_regulator_get(&hdmi.pdev->dev, "vdda");
98 
99 	if (IS_ERR(reg)) {
100 		if (PTR_ERR(reg) != -EPROBE_DEFER)
101 			DSSERR("can't get VDDA regulator\n");
102 		return PTR_ERR(reg);
103 	}
104 
105 	hdmi.vdda_reg = reg;
106 
107 	return 0;
108 }
109 
110 static int hdmi_power_on_core(struct omap_dss_device *dssdev)
111 {
112 	int r;
113 
114 	r = regulator_enable(hdmi.vdda_reg);
115 	if (r)
116 		return r;
117 
118 	r = hdmi_runtime_get();
119 	if (r)
120 		goto err_runtime_get;
121 
122 	/* Make selection of HDMI in DSS */
123 	dss_select_hdmi_venc_clk_source(DSS_HDMI_M_PCLK);
124 
125 	hdmi.core_enabled = true;
126 
127 	return 0;
128 
129 err_runtime_get:
130 	regulator_disable(hdmi.vdda_reg);
131 
132 	return r;
133 }
134 
135 static void hdmi_power_off_core(struct omap_dss_device *dssdev)
136 {
137 	hdmi.core_enabled = false;
138 
139 	hdmi_runtime_put();
140 	regulator_disable(hdmi.vdda_reg);
141 }
142 
143 static int hdmi_power_on_full(struct omap_dss_device *dssdev)
144 {
145 	int r;
146 	struct omap_video_timings *p;
147 	struct omap_overlay_manager *mgr = hdmi.output.manager;
148 	struct hdmi_wp_data *wp = &hdmi.wp;
149 	struct dss_pll_clock_info hdmi_cinfo = { 0 };
150 
151 	r = hdmi_power_on_core(dssdev);
152 	if (r)
153 		return r;
154 
155 	/* disable and clear irqs */
156 	hdmi_wp_clear_irqenable(wp, 0xffffffff);
157 	hdmi_wp_set_irqstatus(wp, 0xffffffff);
158 
159 	p = &hdmi.cfg.timings;
160 
161 	DSSDBG("hdmi_power_on x_res= %d y_res = %d\n", p->x_res, p->y_res);
162 
163 	hdmi_pll_compute(&hdmi.pll, p->pixelclock, &hdmi_cinfo);
164 
165 	r = dss_pll_enable(&hdmi.pll.pll);
166 	if (r) {
167 		DSSERR("Failed to enable PLL\n");
168 		goto err_pll_enable;
169 	}
170 
171 	r = dss_pll_set_config(&hdmi.pll.pll, &hdmi_cinfo);
172 	if (r) {
173 		DSSERR("Failed to configure PLL\n");
174 		goto err_pll_cfg;
175 	}
176 
177 	r = hdmi_phy_configure(&hdmi.phy, hdmi_cinfo.clkdco,
178 		hdmi_cinfo.clkout[0]);
179 	if (r) {
180 		DSSDBG("Failed to configure PHY\n");
181 		goto err_phy_cfg;
182 	}
183 
184 	r = hdmi_wp_set_phy_pwr(wp, HDMI_PHYPWRCMD_LDOON);
185 	if (r)
186 		goto err_phy_pwr;
187 
188 	hdmi4_configure(&hdmi.core, &hdmi.wp, &hdmi.cfg);
189 
190 	/* bypass TV gamma table */
191 	dispc_enable_gamma_table(0);
192 
193 	/* tv size */
194 	dss_mgr_set_timings(mgr, p);
195 
196 	r = hdmi_wp_video_start(&hdmi.wp);
197 	if (r)
198 		goto err_vid_enable;
199 
200 	r = dss_mgr_enable(mgr);
201 	if (r)
202 		goto err_mgr_enable;
203 
204 	hdmi_wp_set_irqenable(wp,
205 		HDMI_IRQ_LINK_CONNECT | HDMI_IRQ_LINK_DISCONNECT);
206 
207 	return 0;
208 
209 err_mgr_enable:
210 	hdmi_wp_video_stop(&hdmi.wp);
211 err_vid_enable:
212 	hdmi_wp_set_phy_pwr(&hdmi.wp, HDMI_PHYPWRCMD_OFF);
213 err_phy_pwr:
214 err_phy_cfg:
215 err_pll_cfg:
216 	dss_pll_disable(&hdmi.pll.pll);
217 err_pll_enable:
218 	hdmi_power_off_core(dssdev);
219 	return -EIO;
220 }
221 
222 static void hdmi_power_off_full(struct omap_dss_device *dssdev)
223 {
224 	struct omap_overlay_manager *mgr = hdmi.output.manager;
225 
226 	hdmi_wp_clear_irqenable(&hdmi.wp, 0xffffffff);
227 
228 	dss_mgr_disable(mgr);
229 
230 	hdmi_wp_video_stop(&hdmi.wp);
231 
232 	hdmi_wp_set_phy_pwr(&hdmi.wp, HDMI_PHYPWRCMD_OFF);
233 
234 	dss_pll_disable(&hdmi.pll.pll);
235 
236 	hdmi_power_off_core(dssdev);
237 }
238 
239 static int hdmi_display_check_timing(struct omap_dss_device *dssdev,
240 					struct omap_video_timings *timings)
241 {
242 	struct omap_dss_device *out = &hdmi.output;
243 
244 	if (!dispc_mgr_timings_ok(out->dispc_channel, timings))
245 		return -EINVAL;
246 
247 	return 0;
248 }
249 
250 static void hdmi_display_set_timing(struct omap_dss_device *dssdev,
251 		struct omap_video_timings *timings)
252 {
253 	mutex_lock(&hdmi.lock);
254 
255 	hdmi.cfg.timings = *timings;
256 
257 	dispc_set_tv_pclk(timings->pixelclock);
258 
259 	mutex_unlock(&hdmi.lock);
260 }
261 
262 static void hdmi_display_get_timings(struct omap_dss_device *dssdev,
263 		struct omap_video_timings *timings)
264 {
265 	*timings = hdmi.cfg.timings;
266 }
267 
268 static void hdmi_dump_regs(struct seq_file *s)
269 {
270 	mutex_lock(&hdmi.lock);
271 
272 	if (hdmi_runtime_get()) {
273 		mutex_unlock(&hdmi.lock);
274 		return;
275 	}
276 
277 	hdmi_wp_dump(&hdmi.wp, s);
278 	hdmi_pll_dump(&hdmi.pll, s);
279 	hdmi_phy_dump(&hdmi.phy, s);
280 	hdmi4_core_dump(&hdmi.core, s);
281 
282 	hdmi_runtime_put();
283 	mutex_unlock(&hdmi.lock);
284 }
285 
286 static int read_edid(u8 *buf, int len)
287 {
288 	int r;
289 
290 	mutex_lock(&hdmi.lock);
291 
292 	r = hdmi_runtime_get();
293 	BUG_ON(r);
294 
295 	r = hdmi4_read_edid(&hdmi.core,  buf, len);
296 
297 	hdmi_runtime_put();
298 	mutex_unlock(&hdmi.lock);
299 
300 	return r;
301 }
302 
303 static void hdmi_start_audio_stream(struct omap_hdmi *hd)
304 {
305 	hdmi_wp_audio_enable(&hd->wp, true);
306 	hdmi4_audio_start(&hd->core, &hd->wp);
307 }
308 
309 static void hdmi_stop_audio_stream(struct omap_hdmi *hd)
310 {
311 	hdmi4_audio_stop(&hd->core, &hd->wp);
312 	hdmi_wp_audio_enable(&hd->wp, false);
313 }
314 
315 static int hdmi_display_enable(struct omap_dss_device *dssdev)
316 {
317 	struct omap_dss_device *out = &hdmi.output;
318 	unsigned long flags;
319 	int r = 0;
320 
321 	DSSDBG("ENTER hdmi_display_enable\n");
322 
323 	mutex_lock(&hdmi.lock);
324 
325 	if (out->manager == NULL) {
326 		DSSERR("failed to enable display: no output/manager\n");
327 		r = -ENODEV;
328 		goto err0;
329 	}
330 
331 	r = hdmi_power_on_full(dssdev);
332 	if (r) {
333 		DSSERR("failed to power on device\n");
334 		goto err0;
335 	}
336 
337 	if (hdmi.audio_configured) {
338 		r = hdmi4_audio_config(&hdmi.core, &hdmi.wp, &hdmi.audio_config,
339 				       hdmi.cfg.timings.pixelclock);
340 		if (r) {
341 			DSSERR("Error restoring audio configuration: %d", r);
342 			hdmi.audio_abort_cb(&hdmi.pdev->dev);
343 			hdmi.audio_configured = false;
344 		}
345 	}
346 
347 	spin_lock_irqsave(&hdmi.audio_playing_lock, flags);
348 	if (hdmi.audio_configured && hdmi.audio_playing)
349 		hdmi_start_audio_stream(&hdmi);
350 	hdmi.display_enabled = true;
351 	spin_unlock_irqrestore(&hdmi.audio_playing_lock, flags);
352 
353 	mutex_unlock(&hdmi.lock);
354 	return 0;
355 
356 err0:
357 	mutex_unlock(&hdmi.lock);
358 	return r;
359 }
360 
361 static void hdmi_display_disable(struct omap_dss_device *dssdev)
362 {
363 	unsigned long flags;
364 
365 	DSSDBG("Enter hdmi_display_disable\n");
366 
367 	mutex_lock(&hdmi.lock);
368 
369 	spin_lock_irqsave(&hdmi.audio_playing_lock, flags);
370 	hdmi_stop_audio_stream(&hdmi);
371 	hdmi.display_enabled = false;
372 	spin_unlock_irqrestore(&hdmi.audio_playing_lock, flags);
373 
374 	hdmi_power_off_full(dssdev);
375 
376 	mutex_unlock(&hdmi.lock);
377 }
378 
379 static int hdmi_core_enable(struct omap_dss_device *dssdev)
380 {
381 	int r = 0;
382 
383 	DSSDBG("ENTER omapdss_hdmi_core_enable\n");
384 
385 	mutex_lock(&hdmi.lock);
386 
387 	r = hdmi_power_on_core(dssdev);
388 	if (r) {
389 		DSSERR("failed to power on device\n");
390 		goto err0;
391 	}
392 
393 	mutex_unlock(&hdmi.lock);
394 	return 0;
395 
396 err0:
397 	mutex_unlock(&hdmi.lock);
398 	return r;
399 }
400 
401 static void hdmi_core_disable(struct omap_dss_device *dssdev)
402 {
403 	DSSDBG("Enter omapdss_hdmi_core_disable\n");
404 
405 	mutex_lock(&hdmi.lock);
406 
407 	hdmi_power_off_core(dssdev);
408 
409 	mutex_unlock(&hdmi.lock);
410 }
411 
412 static int hdmi_connect(struct omap_dss_device *dssdev,
413 		struct omap_dss_device *dst)
414 {
415 	struct omap_overlay_manager *mgr;
416 	int r;
417 
418 	r = hdmi_init_regulator();
419 	if (r)
420 		return r;
421 
422 	mgr = omap_dss_get_overlay_manager(dssdev->dispc_channel);
423 	if (!mgr)
424 		return -ENODEV;
425 
426 	r = dss_mgr_connect(mgr, dssdev);
427 	if (r)
428 		return r;
429 
430 	r = omapdss_output_set_device(dssdev, dst);
431 	if (r) {
432 		DSSERR("failed to connect output to new device: %s\n",
433 				dst->name);
434 		dss_mgr_disconnect(mgr, dssdev);
435 		return r;
436 	}
437 
438 	return 0;
439 }
440 
441 static void hdmi_disconnect(struct omap_dss_device *dssdev,
442 		struct omap_dss_device *dst)
443 {
444 	WARN_ON(dst != dssdev->dst);
445 
446 	if (dst != dssdev->dst)
447 		return;
448 
449 	omapdss_output_unset_device(dssdev);
450 
451 	if (dssdev->manager)
452 		dss_mgr_disconnect(dssdev->manager, dssdev);
453 }
454 
455 static int hdmi_read_edid(struct omap_dss_device *dssdev,
456 		u8 *edid, int len)
457 {
458 	bool need_enable;
459 	int r;
460 
461 	need_enable = hdmi.core_enabled == false;
462 
463 	if (need_enable) {
464 		r = hdmi_core_enable(dssdev);
465 		if (r)
466 			return r;
467 	}
468 
469 	r = read_edid(edid, len);
470 
471 	if (need_enable)
472 		hdmi_core_disable(dssdev);
473 
474 	return r;
475 }
476 
477 static int hdmi_set_infoframe(struct omap_dss_device *dssdev,
478 		const struct hdmi_avi_infoframe *avi)
479 {
480 	hdmi.cfg.infoframe = *avi;
481 	return 0;
482 }
483 
484 static int hdmi_set_hdmi_mode(struct omap_dss_device *dssdev,
485 		bool hdmi_mode)
486 {
487 	hdmi.cfg.hdmi_dvi_mode = hdmi_mode ? HDMI_HDMI : HDMI_DVI;
488 	return 0;
489 }
490 
491 static const struct omapdss_hdmi_ops hdmi_ops = {
492 	.connect		= hdmi_connect,
493 	.disconnect		= hdmi_disconnect,
494 
495 	.enable			= hdmi_display_enable,
496 	.disable		= hdmi_display_disable,
497 
498 	.check_timings		= hdmi_display_check_timing,
499 	.set_timings		= hdmi_display_set_timing,
500 	.get_timings		= hdmi_display_get_timings,
501 
502 	.read_edid		= hdmi_read_edid,
503 	.set_infoframe		= hdmi_set_infoframe,
504 	.set_hdmi_mode		= hdmi_set_hdmi_mode,
505 };
506 
507 static void hdmi_init_output(struct platform_device *pdev)
508 {
509 	struct omap_dss_device *out = &hdmi.output;
510 
511 	out->dev = &pdev->dev;
512 	out->id = OMAP_DSS_OUTPUT_HDMI;
513 	out->output_type = OMAP_DISPLAY_TYPE_HDMI;
514 	out->name = "hdmi.0";
515 	out->dispc_channel = OMAP_DSS_CHANNEL_DIGIT;
516 	out->ops.hdmi = &hdmi_ops;
517 	out->owner = THIS_MODULE;
518 
519 	omapdss_register_output(out);
520 }
521 
522 static void hdmi_uninit_output(struct platform_device *pdev)
523 {
524 	struct omap_dss_device *out = &hdmi.output;
525 
526 	omapdss_unregister_output(out);
527 }
528 
529 static int hdmi_probe_of(struct platform_device *pdev)
530 {
531 	struct device_node *node = pdev->dev.of_node;
532 	struct device_node *ep;
533 	int r;
534 
535 	ep = omapdss_of_get_first_endpoint(node);
536 	if (!ep)
537 		return 0;
538 
539 	r = hdmi_parse_lanes_of(pdev, ep, &hdmi.phy);
540 	if (r)
541 		goto err;
542 
543 	of_node_put(ep);
544 	return 0;
545 
546 err:
547 	of_node_put(ep);
548 	return r;
549 }
550 
551 /* Audio callbacks */
552 static int hdmi_audio_startup(struct device *dev,
553 			      void (*abort_cb)(struct device *dev))
554 {
555 	struct omap_hdmi *hd = dev_get_drvdata(dev);
556 	int ret = 0;
557 
558 	mutex_lock(&hd->lock);
559 
560 	if (!hdmi_mode_has_audio(&hd->cfg) || !hd->display_enabled) {
561 		ret = -EPERM;
562 		goto out;
563 	}
564 
565 	hd->audio_abort_cb = abort_cb;
566 
567 out:
568 	mutex_unlock(&hd->lock);
569 
570 	return ret;
571 }
572 
573 static int hdmi_audio_shutdown(struct device *dev)
574 {
575 	struct omap_hdmi *hd = dev_get_drvdata(dev);
576 
577 	mutex_lock(&hd->lock);
578 	hd->audio_abort_cb = NULL;
579 	hd->audio_configured = false;
580 	hd->audio_playing = false;
581 	mutex_unlock(&hd->lock);
582 
583 	return 0;
584 }
585 
586 static int hdmi_audio_start(struct device *dev)
587 {
588 	struct omap_hdmi *hd = dev_get_drvdata(dev);
589 	unsigned long flags;
590 
591 	WARN_ON(!hdmi_mode_has_audio(&hd->cfg));
592 
593 	spin_lock_irqsave(&hd->audio_playing_lock, flags);
594 
595 	if (hd->display_enabled)
596 		hdmi_start_audio_stream(hd);
597 	hd->audio_playing = true;
598 
599 	spin_unlock_irqrestore(&hd->audio_playing_lock, flags);
600 	return 0;
601 }
602 
603 static void hdmi_audio_stop(struct device *dev)
604 {
605 	struct omap_hdmi *hd = dev_get_drvdata(dev);
606 	unsigned long flags;
607 
608 	WARN_ON(!hdmi_mode_has_audio(&hd->cfg));
609 
610 	spin_lock_irqsave(&hd->audio_playing_lock, flags);
611 
612 	if (hd->display_enabled)
613 		hdmi_stop_audio_stream(hd);
614 	hd->audio_playing = false;
615 
616 	spin_unlock_irqrestore(&hd->audio_playing_lock, flags);
617 }
618 
619 static int hdmi_audio_config(struct device *dev,
620 			     struct omap_dss_audio *dss_audio)
621 {
622 	struct omap_hdmi *hd = dev_get_drvdata(dev);
623 	int ret;
624 
625 	mutex_lock(&hd->lock);
626 
627 	if (!hdmi_mode_has_audio(&hd->cfg) || !hd->display_enabled) {
628 		ret = -EPERM;
629 		goto out;
630 	}
631 
632 	ret = hdmi4_audio_config(&hd->core, &hd->wp, dss_audio,
633 				 hd->cfg.timings.pixelclock);
634 	if (!ret) {
635 		hd->audio_configured = true;
636 		hd->audio_config = *dss_audio;
637 	}
638 out:
639 	mutex_unlock(&hd->lock);
640 
641 	return ret;
642 }
643 
644 static const struct omap_hdmi_audio_ops hdmi_audio_ops = {
645 	.audio_startup = hdmi_audio_startup,
646 	.audio_shutdown = hdmi_audio_shutdown,
647 	.audio_start = hdmi_audio_start,
648 	.audio_stop = hdmi_audio_stop,
649 	.audio_config = hdmi_audio_config,
650 };
651 
652 static int hdmi_audio_register(struct device *dev)
653 {
654 	struct omap_hdmi_audio_pdata pdata = {
655 		.dev = dev,
656 		.version = 4,
657 		.audio_dma_addr = hdmi_wp_get_audio_dma_addr(&hdmi.wp),
658 		.ops = &hdmi_audio_ops,
659 	};
660 
661 	hdmi.audio_pdev = platform_device_register_data(
662 		dev, "omap-hdmi-audio", PLATFORM_DEVID_AUTO,
663 		&pdata, sizeof(pdata));
664 
665 	return PTR_ERR_OR_ZERO(hdmi.audio_pdev);
666 }
667 
668 /* HDMI HW IP initialisation */
669 static int hdmi4_bind(struct device *dev, struct device *master, void *data)
670 {
671 	struct platform_device *pdev = to_platform_device(dev);
672 	int r;
673 	int irq;
674 
675 	hdmi.pdev = pdev;
676 	dev_set_drvdata(&pdev->dev, &hdmi);
677 
678 	mutex_init(&hdmi.lock);
679 	spin_lock_init(&hdmi.audio_playing_lock);
680 
681 	if (pdev->dev.of_node) {
682 		r = hdmi_probe_of(pdev);
683 		if (r)
684 			return r;
685 	}
686 
687 	r = hdmi_wp_init(pdev, &hdmi.wp);
688 	if (r)
689 		return r;
690 
691 	r = hdmi_pll_init(pdev, &hdmi.pll, &hdmi.wp);
692 	if (r)
693 		return r;
694 
695 	r = hdmi_phy_init(pdev, &hdmi.phy);
696 	if (r)
697 		goto err;
698 
699 	r = hdmi4_core_init(pdev, &hdmi.core);
700 	if (r)
701 		goto err;
702 
703 	irq = platform_get_irq(pdev, 0);
704 	if (irq < 0) {
705 		DSSERR("platform_get_irq failed\n");
706 		r = -ENODEV;
707 		goto err;
708 	}
709 
710 	r = devm_request_threaded_irq(&pdev->dev, irq,
711 			NULL, hdmi_irq_handler,
712 			IRQF_ONESHOT, "OMAP HDMI", &hdmi.wp);
713 	if (r) {
714 		DSSERR("HDMI IRQ request failed\n");
715 		goto err;
716 	}
717 
718 	pm_runtime_enable(&pdev->dev);
719 
720 	hdmi_init_output(pdev);
721 
722 	r = hdmi_audio_register(&pdev->dev);
723 	if (r) {
724 		DSSERR("Registering HDMI audio failed\n");
725 		hdmi_uninit_output(pdev);
726 		pm_runtime_disable(&pdev->dev);
727 		return r;
728 	}
729 
730 	dss_debugfs_create_file("hdmi", hdmi_dump_regs);
731 
732 	return 0;
733 err:
734 	hdmi_pll_uninit(&hdmi.pll);
735 	return r;
736 }
737 
738 static void hdmi4_unbind(struct device *dev, struct device *master, void *data)
739 {
740 	struct platform_device *pdev = to_platform_device(dev);
741 
742 	if (hdmi.audio_pdev)
743 		platform_device_unregister(hdmi.audio_pdev);
744 
745 	hdmi_uninit_output(pdev);
746 
747 	hdmi_pll_uninit(&hdmi.pll);
748 
749 	pm_runtime_disable(&pdev->dev);
750 }
751 
752 static const struct component_ops hdmi4_component_ops = {
753 	.bind	= hdmi4_bind,
754 	.unbind	= hdmi4_unbind,
755 };
756 
757 static int hdmi4_probe(struct platform_device *pdev)
758 {
759 	return component_add(&pdev->dev, &hdmi4_component_ops);
760 }
761 
762 static int hdmi4_remove(struct platform_device *pdev)
763 {
764 	component_del(&pdev->dev, &hdmi4_component_ops);
765 	return 0;
766 }
767 
768 static int hdmi_runtime_suspend(struct device *dev)
769 {
770 	dispc_runtime_put();
771 
772 	return 0;
773 }
774 
775 static int hdmi_runtime_resume(struct device *dev)
776 {
777 	int r;
778 
779 	r = dispc_runtime_get();
780 	if (r < 0)
781 		return r;
782 
783 	return 0;
784 }
785 
786 static const struct dev_pm_ops hdmi_pm_ops = {
787 	.runtime_suspend = hdmi_runtime_suspend,
788 	.runtime_resume = hdmi_runtime_resume,
789 };
790 
791 static const struct of_device_id hdmi_of_match[] = {
792 	{ .compatible = "ti,omap4-hdmi", },
793 	{},
794 };
795 
796 static struct platform_driver omapdss_hdmihw_driver = {
797 	.probe		= hdmi4_probe,
798 	.remove		= hdmi4_remove,
799 	.driver         = {
800 		.name   = "omapdss_hdmi",
801 		.pm	= &hdmi_pm_ops,
802 		.of_match_table = hdmi_of_match,
803 		.suppress_bind_attrs = true,
804 	},
805 };
806 
807 int __init hdmi4_init_platform_driver(void)
808 {
809 	return platform_driver_register(&omapdss_hdmihw_driver);
810 }
811 
812 void hdmi4_uninit_platform_driver(void)
813 {
814 	platform_driver_unregister(&omapdss_hdmihw_driver);
815 }
816