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