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

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