drivers/gpu/drm/msm/hdmi/hdmi.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (c) 2014 The Linux Foundation. All rights reserved.
   4  * Copyright (C) 2013 Red Hat
   5  * Author: Rob Clark <robdclark@gmail.com>
   6  */
   7
   8 #include <linux/of_irq.h>
   9 #include <linux/of_gpio.h>
  10
  11 #include <drm/drm_bridge_connector.h>
  12 #include <drm/drm_of.h>
  13
  14 #include <sound/hdmi-codec.h>
  15 #include "hdmi.h"
  16
  17 void msm_hdmi_set_mode(struct hdmi *hdmi, bool power_on)
  18 {
  19         uint32_t ctrl = 0;
  20         unsigned long flags;
  21
  22         spin_lock_irqsave(&hdmi->reg_lock, flags);
  23         if (power_on) {
  24                 ctrl |= HDMI_CTRL_ENABLE;
  25                 if (!hdmi->hdmi_mode) {
  26                         ctrl |= HDMI_CTRL_HDMI;
  27                         hdmi_write(hdmi, REG_HDMI_CTRL, ctrl);
  28                         ctrl &= ~HDMI_CTRL_HDMI;
  29                 } else {
  30                         ctrl |= HDMI_CTRL_HDMI;
  31                 }
  32         } else {
  33                 ctrl = HDMI_CTRL_HDMI;
  34         }
  35
  36         hdmi_write(hdmi, REG_HDMI_CTRL, ctrl);
  37         spin_unlock_irqrestore(&hdmi->reg_lock, flags);
  38         DBG("HDMI Core: %s, HDMI_CTRL=0x%08x",
  39                         power_on ? "Enable" : "Disable", ctrl);
  40 }
  41
  42 static irqreturn_t msm_hdmi_irq(int irq, void *dev_id)
  43 {
  44         struct hdmi *hdmi = dev_id;
  45
  46         /* Process HPD: */
  47         msm_hdmi_hpd_irq(hdmi->bridge);
  48
  49         /* Process DDC: */
  50         msm_hdmi_i2c_irq(hdmi->i2c);
  51
  52         /* Process HDCP: */
  53         if (hdmi->hdcp_ctrl)
  54                 msm_hdmi_hdcp_irq(hdmi->hdcp_ctrl);
  55
  56         /* TODO audio.. */
  57
  58         return IRQ_HANDLED;
  59 }
  60
  61 static void msm_hdmi_destroy(struct hdmi *hdmi)
  62 {
  63         /*
  64          * at this point, hpd has been disabled,
  65          * after flush workq, it's safe to deinit hdcp
  66          */
  67         if (hdmi->workq)
  68                 destroy_workqueue(hdmi->workq);
  69         msm_hdmi_hdcp_destroy(hdmi);
  70
  71         if (hdmi->i2c)
  72                 msm_hdmi_i2c_destroy(hdmi->i2c);
  73 }
  74
  75 static void msm_hdmi_put_phy(struct hdmi *hdmi)
  76 {
  77         if (hdmi->phy_dev) {
  78                 put_device(hdmi->phy_dev);
  79                 hdmi->phy = NULL;
  80                 hdmi->phy_dev = NULL;
  81         }
  82 }
  83
  84 static int msm_hdmi_get_phy(struct hdmi *hdmi)
  85 {
  86         struct platform_device *pdev = hdmi->pdev;
  87         struct platform_device *phy_pdev;
  88         struct device_node *phy_node;
  89
  90         phy_node = of_parse_phandle(pdev->dev.of_node, "phys", 0);
  91         if (!phy_node) {
  92                 DRM_DEV_ERROR(&pdev->dev, "cannot find phy device\n");
  93                 return -ENXIO;
  94         }
  95
  96         phy_pdev = of_find_device_by_node(phy_node);
  97         of_node_put(phy_node);
  98
  99         if (!phy_pdev)
 100                 return dev_err_probe(&pdev->dev, -EPROBE_DEFER, "phy driver is not ready\n");
 101
 102         hdmi->phy = platform_get_drvdata(phy_pdev);
 103         if (!hdmi->phy) {
 104                 put_device(&phy_pdev->dev);
 105                 return dev_err_probe(&pdev->dev, -EPROBE_DEFER, "phy driver is not ready\n");
 106         }
 107
 108         hdmi->phy_dev = &phy_pdev->dev;
 109
 110         return 0;
 111 }
 112
 113 /* construct hdmi at bind/probe time, grab all the resources.  If
 114  * we are to EPROBE_DEFER we want to do it here, rather than later
 115  * at modeset_init() time
 116  */
 117 static int msm_hdmi_init(struct hdmi *hdmi)
 118 {
 119         struct platform_device *pdev = hdmi->pdev;
 120         int ret;
 121
 122         hdmi->workq = alloc_ordered_workqueue("msm_hdmi", 0);
 123
 124         hdmi->i2c = msm_hdmi_i2c_init(hdmi);
 125         if (IS_ERR(hdmi->i2c)) {
 126                 ret = PTR_ERR(hdmi->i2c);
 127                 DRM_DEV_ERROR(&pdev->dev, "failed to get i2c: %d\n", ret);
 128                 hdmi->i2c = NULL;
 129                 goto fail;
 130         }
 131
 132         hdmi->hdcp_ctrl = msm_hdmi_hdcp_init(hdmi);
 133         if (IS_ERR(hdmi->hdcp_ctrl)) {
 134                 dev_warn(&pdev->dev, "failed to init hdcp: disabled\n");
 135                 hdmi->hdcp_ctrl = NULL;
 136         }
 137
 138         return 0;
 139
 140 fail:
 141         msm_hdmi_destroy(hdmi);
 142
 143         return ret;
 144 }
 145
 146 /* Second part of initialization, the drm/kms level modeset_init,
 147  * constructs/initializes mode objects, etc, is called from master
 148  * driver (not hdmi sub-device's probe/bind!)
 149  *
 150  * Any resource (regulator/clk/etc) which could be missing at boot
 151  * should be handled in msm_hdmi_init() so that failure happens from
 152  * hdmi sub-device's probe.
 153  */
 154 int msm_hdmi_modeset_init(struct hdmi *hdmi,
 155                 struct drm_device *dev, struct drm_encoder *encoder)
 156 {
 157         struct msm_drm_private *priv = dev->dev_private;
 158         int ret;
 159
 160         if (priv->num_bridges == ARRAY_SIZE(priv->bridges)) {
 161                 DRM_DEV_ERROR(dev->dev, "too many bridges\n");
 162                 return -ENOSPC;
 163         }
 164
 165         hdmi->dev = dev;
 166         hdmi->encoder = encoder;
 167
 168         hdmi_audio_infoframe_init(&hdmi->audio.infoframe);
 169
 170         hdmi->bridge = msm_hdmi_bridge_init(hdmi);
 171         if (IS_ERR(hdmi->bridge)) {
 172                 ret = PTR_ERR(hdmi->bridge);
 173                 DRM_DEV_ERROR(dev->dev, "failed to create HDMI bridge: %d\n", ret);
 174                 hdmi->bridge = NULL;
 175                 goto fail;
 176         }
 177
 178         if (hdmi->next_bridge) {
 179                 ret = drm_bridge_attach(hdmi->encoder, hdmi->next_bridge, hdmi->bridge,
 180                                         DRM_BRIDGE_ATTACH_NO_CONNECTOR);
 181                 if (ret) {
 182                         DRM_DEV_ERROR(dev->dev, "failed to attach next HDMI bridge: %d\n", ret);
 183                         goto fail;
 184                 }
 185         }
 186
 187         hdmi->connector = drm_bridge_connector_init(hdmi->dev, encoder);
 188         if (IS_ERR(hdmi->connector)) {
 189                 ret = PTR_ERR(hdmi->connector);
 190                 DRM_DEV_ERROR(dev->dev, "failed to create HDMI connector: %d\n", ret);
 191                 hdmi->connector = NULL;
 192                 goto fail;
 193         }
 194
 195         drm_connector_attach_encoder(hdmi->connector, hdmi->encoder);
 196
 197         ret = devm_request_irq(dev->dev, hdmi->irq,
 198                         msm_hdmi_irq, IRQF_TRIGGER_HIGH,
 199                         "hdmi_isr", hdmi);
 200         if (ret < 0) {
 201                 DRM_DEV_ERROR(dev->dev, "failed to request IRQ%u: %d\n",
 202                                 hdmi->irq, ret);
 203                 goto fail;
 204         }
 205
 206         ret = msm_hdmi_hpd_enable(hdmi->bridge);
 207         if (ret < 0) {
 208                 DRM_DEV_ERROR(&hdmi->pdev->dev, "failed to enable HPD: %d\n", ret);
 209                 goto fail;
 210         }
 211
 212         priv->bridges[priv->num_bridges++]       = hdmi->bridge;
 213
 214         return 0;
 215
 216 fail:
 217         /* bridge is normally destroyed by drm: */
 218         if (hdmi->bridge) {
 219                 msm_hdmi_bridge_destroy(hdmi->bridge);
 220                 hdmi->bridge = NULL;
 221         }
 222         if (hdmi->connector) {
 223                 hdmi->connector->funcs->destroy(hdmi->connector);
 224                 hdmi->connector = NULL;
 225         }
 226
 227         return ret;
 228 }
 229
 230 /*
 231  * The hdmi device:
 232  */
 233
 234 #define HDMI_CFG(item, entry) \
 235         .item ## _names = item ##_names_ ## entry, \
 236         .item ## _cnt   = ARRAY_SIZE(item ## _names_ ## entry)
 237
 238 static const char *hpd_reg_names_8960[] = {"core-vdda"};
 239 static const char *hpd_clk_names_8960[] = {"core", "master_iface", "slave_iface"};
 240
 241 static const struct hdmi_platform_config hdmi_tx_8960_config = {
 242                 HDMI_CFG(hpd_reg, 8960),
 243                 HDMI_CFG(hpd_clk, 8960),
 244 };
 245
 246 static const char *pwr_reg_names_8x74[] = {"core-vdda", "core-vcc"};
 247 static const char *pwr_clk_names_8x74[] = {"extp", "alt_iface"};
 248 static const char *hpd_clk_names_8x74[] = {"iface", "core", "mdp_core"};
 249 static unsigned long hpd_clk_freq_8x74[] = {0, 19200000, 0};
 250
 251 static const struct hdmi_platform_config hdmi_tx_8974_config = {
 252                 HDMI_CFG(pwr_reg, 8x74),
 253                 HDMI_CFG(pwr_clk, 8x74),
 254                 HDMI_CFG(hpd_clk, 8x74),
 255                 .hpd_freq      = hpd_clk_freq_8x74,
 256 };
 257
 258 /*
 259  * HDMI audio codec callbacks
 260  */
 261 static int msm_hdmi_audio_hw_params(struct device *dev, void *data,
 262                                     struct hdmi_codec_daifmt *daifmt,
 263                                     struct hdmi_codec_params *params)
 264 {
 265         struct hdmi *hdmi = dev_get_drvdata(dev);
 266         unsigned int chan;
 267         unsigned int channel_allocation = 0;
 268         unsigned int rate;
 269         unsigned int level_shift  = 0; /* 0dB */
 270         bool down_mix = false;
 271
 272         DRM_DEV_DEBUG(dev, "%u Hz, %d bit, %d channels\n", params->sample_rate,
 273                  params->sample_width, params->cea.channels);
 274
 275         switch (params->cea.channels) {
 276         case 2:
 277                 /* FR and FL speakers */
 278                 channel_allocation  = 0;
 279                 chan = MSM_HDMI_AUDIO_CHANNEL_2;
 280                 break;
 281         case 4:
 282                 /* FC, LFE, FR and FL speakers */
 283                 channel_allocation  = 0x3;
 284                 chan = MSM_HDMI_AUDIO_CHANNEL_4;
 285                 break;
 286         case 6:
 287                 /* RR, RL, FC, LFE, FR and FL speakers */
 288                 channel_allocation  = 0x0B;
 289                 chan = MSM_HDMI_AUDIO_CHANNEL_6;
 290                 break;
 291         case 8:
 292                 /* FRC, FLC, RR, RL, FC, LFE, FR and FL speakers */
 293                 channel_allocation  = 0x1F;
 294                 chan = MSM_HDMI_AUDIO_CHANNEL_8;
 295                 break;
 296         default:
 297                 return -EINVAL;
 298         }
 299
 300         switch (params->sample_rate) {
 301         case 32000:
 302                 rate = HDMI_SAMPLE_RATE_32KHZ;
 303                 break;
 304         case 44100:
 305                 rate = HDMI_SAMPLE_RATE_44_1KHZ;
 306                 break;
 307         case 48000:
 308                 rate = HDMI_SAMPLE_RATE_48KHZ;
 309                 break;
 310         case 88200:
 311                 rate = HDMI_SAMPLE_RATE_88_2KHZ;
 312                 break;
 313         case 96000:
 314                 rate = HDMI_SAMPLE_RATE_96KHZ;
 315                 break;
 316         case 176400:
 317                 rate = HDMI_SAMPLE_RATE_176_4KHZ;
 318                 break;
 319         case 192000:
 320                 rate = HDMI_SAMPLE_RATE_192KHZ;
 321                 break;
 322         default:
 323                 DRM_DEV_ERROR(dev, "rate[%d] not supported!\n",
 324                         params->sample_rate);
 325                 return -EINVAL;
 326         }
 327
 328         msm_hdmi_audio_set_sample_rate(hdmi, rate);
 329         msm_hdmi_audio_info_setup(hdmi, 1, chan, channel_allocation,
 330                               level_shift, down_mix);
 331
 332         return 0;
 333 }
 334
 335 static void msm_hdmi_audio_shutdown(struct device *dev, void *data)
 336 {
 337         struct hdmi *hdmi = dev_get_drvdata(dev);
 338
 339         msm_hdmi_audio_info_setup(hdmi, 0, 0, 0, 0, 0);
 340 }
 341
 342 static const struct hdmi_codec_ops msm_hdmi_audio_codec_ops = {
 343         .hw_params = msm_hdmi_audio_hw_params,
 344         .audio_shutdown = msm_hdmi_audio_shutdown,
 345 };
 346
 347 static struct hdmi_codec_pdata codec_data = {
 348         .ops = &msm_hdmi_audio_codec_ops,
 349         .max_i2s_channels = 8,
 350         .i2s = 1,
 351 };
 352
 353 static int msm_hdmi_register_audio_driver(struct hdmi *hdmi, struct device *dev)
 354 {
 355         hdmi->audio_pdev = platform_device_register_data(dev,
 356                                                          HDMI_CODEC_DRV_NAME,
 357                                                          PLATFORM_DEVID_AUTO,
 358                                                          &codec_data,
 359                                                          sizeof(codec_data));
 360         return PTR_ERR_OR_ZERO(hdmi->audio_pdev);
 361 }
 362
 363 static int msm_hdmi_bind(struct device *dev, struct device *master, void *data)
 364 {
 365         struct msm_drm_private *priv = dev_get_drvdata(master);
 366         struct hdmi *hdmi = dev_get_drvdata(dev);
 367         int err;
 368
 369         err = msm_hdmi_init(hdmi);
 370         if (err)
 371                 return err;
 372         priv->hdmi = hdmi;
 373
 374         err = msm_hdmi_register_audio_driver(hdmi, dev);
 375         if (err) {
 376                 DRM_ERROR("Failed to attach an audio codec %d\n", err);
 377                 hdmi->audio_pdev = NULL;
 378         }
 379
 380         return 0;
 381 }
 382
 383 static void msm_hdmi_unbind(struct device *dev, struct device *master,
 384                 void *data)
 385 {
 386         struct msm_drm_private *priv = dev_get_drvdata(master);
 387
 388         if (priv->hdmi) {
 389                 if (priv->hdmi->audio_pdev)
 390                         platform_device_unregister(priv->hdmi->audio_pdev);
 391
 392                 msm_hdmi_destroy(priv->hdmi);
 393                 priv->hdmi = NULL;
 394         }
 395 }
 396
 397 static const struct component_ops msm_hdmi_ops = {
 398                 .bind   = msm_hdmi_bind,
 399                 .unbind = msm_hdmi_unbind,
 400 };
 401
 402 static int msm_hdmi_dev_probe(struct platform_device *pdev)
 403 {
 404         const struct hdmi_platform_config *config;
 405         struct device *dev = &pdev->dev;
 406         struct hdmi *hdmi;
 407         struct resource *res;
 408         int i, ret;
 409
 410         config = of_device_get_match_data(dev);
 411         if (!config)
 412                 return -EINVAL;
 413
 414         hdmi = devm_kzalloc(&pdev->dev, sizeof(*hdmi), GFP_KERNEL);
 415         if (!hdmi)
 416                 return -ENOMEM;
 417
 418         hdmi->pdev = pdev;
 419         hdmi->config = config;
 420         spin_lock_init(&hdmi->reg_lock);
 421
 422         ret = drm_of_find_panel_or_bridge(pdev->dev.of_node, 1, 0, NULL, &hdmi->next_bridge);
 423         if (ret && ret != -ENODEV)
 424                 return ret;
 425
 426         hdmi->mmio = msm_ioremap(pdev, "core_physical");
 427         if (IS_ERR(hdmi->mmio))
 428                 return PTR_ERR(hdmi->mmio);
 429
 430         /* HDCP needs physical address of hdmi register */
 431         res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
 432                 "core_physical");
 433         if (!res)
 434                 return -EINVAL;
 435         hdmi->mmio_phy_addr = res->start;
 436
 437         hdmi->qfprom_mmio = msm_ioremap(pdev, "qfprom_physical");
 438         if (IS_ERR(hdmi->qfprom_mmio)) {
 439                 DRM_DEV_INFO(&pdev->dev, "can't find qfprom resource\n");
 440                 hdmi->qfprom_mmio = NULL;
 441         }
 442
 443         hdmi->irq = platform_get_irq(pdev, 0);
 444         if (hdmi->irq < 0)
 445                 return hdmi->irq;
 446
 447         hdmi->hpd_regs = devm_kcalloc(&pdev->dev,
 448                                       config->hpd_reg_cnt,
 449                                       sizeof(hdmi->hpd_regs[0]),
 450                                       GFP_KERNEL);
 451         if (!hdmi->hpd_regs)
 452                 return -ENOMEM;
 453
 454         for (i = 0; i < config->hpd_reg_cnt; i++)
 455                 hdmi->hpd_regs[i].supply = config->hpd_reg_names[i];
 456
 457         ret = devm_regulator_bulk_get(&pdev->dev, config->hpd_reg_cnt, hdmi->hpd_regs);
 458         if (ret)
 459                 return dev_err_probe(dev, ret, "failed to get hpd regulators\n");
 460
 461         hdmi->pwr_regs = devm_kcalloc(&pdev->dev,
 462                                       config->pwr_reg_cnt,
 463                                       sizeof(hdmi->pwr_regs[0]),
 464                                       GFP_KERNEL);
 465         if (!hdmi->pwr_regs)
 466                 return -ENOMEM;
 467
 468         for (i = 0; i < config->pwr_reg_cnt; i++)
 469                 hdmi->pwr_regs[i].supply = config->pwr_reg_names[i];
 470
 471         ret = devm_regulator_bulk_get(&pdev->dev, config->pwr_reg_cnt, hdmi->pwr_regs);
 472         if (ret)
 473                 return dev_err_probe(dev, ret, "failed to get pwr regulators\n");
 474
 475         hdmi->hpd_clks = devm_kcalloc(&pdev->dev,
 476                                       config->hpd_clk_cnt,
 477                                       sizeof(hdmi->hpd_clks[0]),
 478                                       GFP_KERNEL);
 479         if (!hdmi->hpd_clks)
 480                 return -ENOMEM;
 481
 482         for (i = 0; i < config->hpd_clk_cnt; i++) {
 483                 struct clk *clk;
 484
 485                 clk = msm_clk_get(pdev, config->hpd_clk_names[i]);
 486                 if (IS_ERR(clk))
 487                         return dev_err_probe(dev, PTR_ERR(clk),
 488                                              "failed to get hpd clk: %s\n",
 489                                              config->hpd_clk_names[i]);
 490
 491                 hdmi->hpd_clks[i] = clk;
 492         }
 493
 494         hdmi->pwr_clks = devm_kcalloc(&pdev->dev,
 495                                       config->pwr_clk_cnt,
 496                                       sizeof(hdmi->pwr_clks[0]),
 497                                       GFP_KERNEL);
 498         if (!hdmi->pwr_clks)
 499                 return -ENOMEM;
 500
 501         for (i = 0; i < config->pwr_clk_cnt; i++) {
 502                 struct clk *clk;
 503
 504                 clk = msm_clk_get(pdev, config->pwr_clk_names[i]);
 505                 if (IS_ERR(clk))
 506                         return dev_err_probe(dev, PTR_ERR(clk),
 507                                              "failed to get pwr clk: %s\n",
 508                                              config->pwr_clk_names[i]);
 509
 510                 hdmi->pwr_clks[i] = clk;
 511         }
 512
 513         hdmi->hpd_gpiod = devm_gpiod_get_optional(&pdev->dev, "hpd", GPIOD_IN);
 514         /* This will catch e.g. -EPROBE_DEFER */
 515         if (IS_ERR(hdmi->hpd_gpiod))
 516                 return dev_err_probe(dev, PTR_ERR(hdmi->hpd_gpiod),
 517                                      "failed to get hpd gpio\n");
 518
 519         if (!hdmi->hpd_gpiod)
 520                 DBG("failed to get HPD gpio");
 521
 522         if (hdmi->hpd_gpiod)
 523                 gpiod_set_consumer_name(hdmi->hpd_gpiod, "HDMI_HPD");
 524
 525         ret = msm_hdmi_get_phy(hdmi);
 526         if (ret) {
 527                 DRM_DEV_ERROR(&pdev->dev, "failed to get phy\n");
 528                 return ret;
 529         }
 530
 531         ret = devm_pm_runtime_enable(&pdev->dev);
 532         if (ret)
 533                 return ret;
 534
 535         platform_set_drvdata(pdev, hdmi);
 536
 537         return component_add(&pdev->dev, &msm_hdmi_ops);
 538 }
 539
 540 static int msm_hdmi_dev_remove(struct platform_device *pdev)
 541 {
 542         struct hdmi *hdmi = dev_get_drvdata(&pdev->dev);
 543
 544         component_del(&pdev->dev, &msm_hdmi_ops);
 545
 546         msm_hdmi_put_phy(hdmi);
 547
 548         return 0;
 549 }
 550
 551 static const struct of_device_id msm_hdmi_dt_match[] = {
 552         { .compatible = "qcom,hdmi-tx-8996", .data = &hdmi_tx_8974_config },
 553         { .compatible = "qcom,hdmi-tx-8994", .data = &hdmi_tx_8974_config },
 554         { .compatible = "qcom,hdmi-tx-8084", .data = &hdmi_tx_8974_config },
 555         { .compatible = "qcom,hdmi-tx-8974", .data = &hdmi_tx_8974_config },
 556         { .compatible = "qcom,hdmi-tx-8960", .data = &hdmi_tx_8960_config },
 557         { .compatible = "qcom,hdmi-tx-8660", .data = &hdmi_tx_8960_config },
 558         {}
 559 };
 560
 561 static struct platform_driver msm_hdmi_driver = {
 562         .probe = msm_hdmi_dev_probe,
 563         .remove = msm_hdmi_dev_remove,
 564         .driver = {
 565                 .name = "hdmi_msm",
 566                 .of_match_table = msm_hdmi_dt_match,
 567         },
 568 };
 569
 570 void __init msm_hdmi_register(void)
 571 {
 572         msm_hdmi_phy_driver_register();
 573         platform_driver_register(&msm_hdmi_driver);
 574 }
 575
 576 void __exit msm_hdmi_unregister(void)
 577 {
 578         platform_driver_unregister(&msm_hdmi_driver);
 579         msm_hdmi_phy_driver_unregister();
 580 }