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 <[email protected]>
   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 };