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