drivers/gpu/drm/omapdrm/dss/hdmi4.c

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