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

   1 /*
   2  * Copyright (c) 2014 The Linux Foundation. All rights reserved.
   3  * Copyright (C) 2013 Red Hat
   4  * Author: Rob Clark <robdclark@gmail.com>
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License version 2 as published by
   8  * the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  13  * more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along with
  16  * this program.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 #include <linux/of_irq.h>
  20 #include <linux/of_gpio.h>
  21
  22 #include "hdmi.h"
  23
  24 void hdmi_set_mode(struct hdmi *hdmi, bool power_on)
  25 {
  26         uint32_t ctrl = 0;
  27         unsigned long flags;
  28
  29         spin_lock_irqsave(&hdmi->reg_lock, flags);
  30         if (power_on) {
  31                 ctrl |= HDMI_CTRL_ENABLE;
  32                 if (!hdmi->hdmi_mode) {
  33                         ctrl |= HDMI_CTRL_HDMI;
  34                         hdmi_write(hdmi, REG_HDMI_CTRL, ctrl);
  35                         ctrl &= ~HDMI_CTRL_HDMI;
  36                 } else {
  37                         ctrl |= HDMI_CTRL_HDMI;
  38                 }
  39         } else {
  40                 ctrl = HDMI_CTRL_HDMI;
  41         }
  42
  43         hdmi_write(hdmi, REG_HDMI_CTRL, ctrl);
  44         spin_unlock_irqrestore(&hdmi->reg_lock, flags);
  45         DBG("HDMI Core: %s, HDMI_CTRL=0x%08x",
  46                         power_on ? "Enable" : "Disable", ctrl);
  47 }
  48
  49 static irqreturn_t hdmi_irq(int irq, void *dev_id)
  50 {
  51         struct hdmi *hdmi = dev_id;
  52
  53         /* Process HPD: */
  54         hdmi_connector_irq(hdmi->connector);
  55
  56         /* Process DDC: */
  57         hdmi_i2c_irq(hdmi->i2c);
  58
  59         /* Process HDCP: */
  60         if (hdmi->hdcp_ctrl)
  61                 hdmi_hdcp_irq(hdmi->hdcp_ctrl);
  62
  63         /* TODO audio.. */
  64
  65         return IRQ_HANDLED;
  66 }
  67
  68 static void hdmi_destroy(struct hdmi *hdmi)
  69 {
  70         struct hdmi_phy *phy = hdmi->phy;
  71
  72         /*
  73          * at this point, hpd has been disabled,
  74          * after flush workq, it's safe to deinit hdcp
  75          */
  76         if (hdmi->workq) {
  77                 flush_workqueue(hdmi->workq);
  78                 destroy_workqueue(hdmi->workq);
  79         }
  80         hdmi_hdcp_destroy(hdmi);
  81         if (phy)
  82                 phy->funcs->destroy(phy);
  83
  84         if (hdmi->i2c)
  85                 hdmi_i2c_destroy(hdmi->i2c);
  86
  87         platform_set_drvdata(hdmi->pdev, NULL);
  88 }
  89
  90 /* construct hdmi at bind/probe time, grab all the resources.  If
  91  * we are to EPROBE_DEFER we want to do it here, rather than later
  92  * at modeset_init() time
  93  */
  94 static struct hdmi *hdmi_init(struct platform_device *pdev)
  95 {
  96         struct hdmi_platform_config *config = pdev->dev.platform_data;
  97         struct hdmi *hdmi = NULL;
  98         struct resource *res;
  99         int i, ret;
 100
 101         hdmi = devm_kzalloc(&pdev->dev, sizeof(*hdmi), GFP_KERNEL);
 102         if (!hdmi) {
 103                 ret = -ENOMEM;
 104                 goto fail;
 105         }
 106
 107         hdmi->pdev = pdev;
 108         hdmi->config = config;
 109         spin_lock_init(&hdmi->reg_lock);
 110
 111         /* not sure about which phy maps to which msm.. probably I miss some */
 112         if (config->phy_init) {
 113                 hdmi->phy = config->phy_init(hdmi);
 114
 115                 if (IS_ERR(hdmi->phy)) {
 116                         ret = PTR_ERR(hdmi->phy);
 117                         dev_err(&pdev->dev, "failed to load phy: %d\n", ret);
 118                         hdmi->phy = NULL;
 119                         goto fail;
 120                 }
 121         }
 122
 123         hdmi->mmio = msm_ioremap(pdev, config->mmio_name, "HDMI");
 124         if (IS_ERR(hdmi->mmio)) {
 125                 ret = PTR_ERR(hdmi->mmio);
 126                 goto fail;
 127         }
 128
 129         /* HDCP needs physical address of hdmi register */
 130         res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
 131                 config->mmio_name);
 132         hdmi->mmio_phy_addr = res->start;
 133
 134         hdmi->qfprom_mmio = msm_ioremap(pdev,
 135                 config->qfprom_mmio_name, "HDMI_QFPROM");
 136         if (IS_ERR(hdmi->qfprom_mmio)) {
 137                 dev_info(&pdev->dev, "can't find qfprom resource\n");
 138                 hdmi->qfprom_mmio = NULL;
 139         }
 140
 141         hdmi->hpd_regs = devm_kzalloc(&pdev->dev, sizeof(hdmi->hpd_regs[0]) *
 142                         config->hpd_reg_cnt, GFP_KERNEL);
 143         if (!hdmi->hpd_regs) {
 144                 ret = -ENOMEM;
 145                 goto fail;
 146         }
 147         for (i = 0; i < config->hpd_reg_cnt; i++) {
 148                 struct regulator *reg;
 149
 150                 reg = devm_regulator_get(&pdev->dev,
 151                                 config->hpd_reg_names[i]);
 152                 if (IS_ERR(reg)) {
 153                         ret = PTR_ERR(reg);
 154                         dev_err(&pdev->dev, "failed to get hpd regulator: %s (%d)\n",
 155                                         config->hpd_reg_names[i], ret);
 156                         goto fail;
 157                 }
 158
 159                 hdmi->hpd_regs[i] = reg;
 160         }
 161
 162         hdmi->pwr_regs = devm_kzalloc(&pdev->dev, sizeof(hdmi->pwr_regs[0]) *
 163                         config->pwr_reg_cnt, GFP_KERNEL);
 164         if (!hdmi->pwr_regs) {
 165                 ret = -ENOMEM;
 166                 goto fail;
 167         }
 168         for (i = 0; i < config->pwr_reg_cnt; i++) {
 169                 struct regulator *reg;
 170
 171                 reg = devm_regulator_get(&pdev->dev,
 172                                 config->pwr_reg_names[i]);
 173                 if (IS_ERR(reg)) {
 174                         ret = PTR_ERR(reg);
 175                         dev_err(&pdev->dev, "failed to get pwr regulator: %s (%d)\n",
 176                                         config->pwr_reg_names[i], ret);
 177                         goto fail;
 178                 }
 179
 180                 hdmi->pwr_regs[i] = reg;
 181         }
 182
 183         hdmi->hpd_clks = devm_kzalloc(&pdev->dev, sizeof(hdmi->hpd_clks[0]) *
 184                         config->hpd_clk_cnt, GFP_KERNEL);
 185         if (!hdmi->hpd_clks) {
 186                 ret = -ENOMEM;
 187                 goto fail;
 188         }
 189         for (i = 0; i < config->hpd_clk_cnt; i++) {
 190                 struct clk *clk;
 191
 192                 clk = devm_clk_get(&pdev->dev, config->hpd_clk_names[i]);
 193                 if (IS_ERR(clk)) {
 194                         ret = PTR_ERR(clk);
 195                         dev_err(&pdev->dev, "failed to get hpd clk: %s (%d)\n",
 196                                         config->hpd_clk_names[i], ret);
 197                         goto fail;
 198                 }
 199
 200                 hdmi->hpd_clks[i] = clk;
 201         }
 202
 203         hdmi->pwr_clks = devm_kzalloc(&pdev->dev, sizeof(hdmi->pwr_clks[0]) *
 204                         config->pwr_clk_cnt, GFP_KERNEL);
 205         if (!hdmi->pwr_clks) {
 206                 ret = -ENOMEM;
 207                 goto fail;
 208         }
 209         for (i = 0; i < config->pwr_clk_cnt; i++) {
 210                 struct clk *clk;
 211
 212                 clk = devm_clk_get(&pdev->dev, config->pwr_clk_names[i]);
 213                 if (IS_ERR(clk)) {
 214                         ret = PTR_ERR(clk);
 215                         dev_err(&pdev->dev, "failed to get pwr clk: %s (%d)\n",
 216                                         config->pwr_clk_names[i], ret);
 217                         goto fail;
 218                 }
 219
 220                 hdmi->pwr_clks[i] = clk;
 221         }
 222
 223         hdmi->workq = alloc_ordered_workqueue("msm_hdmi", 0);
 224
 225         hdmi->i2c = hdmi_i2c_init(hdmi);
 226         if (IS_ERR(hdmi->i2c)) {
 227                 ret = PTR_ERR(hdmi->i2c);
 228                 dev_err(&pdev->dev, "failed to get i2c: %d\n", ret);
 229                 hdmi->i2c = NULL;
 230                 goto fail;
 231         }
 232
 233         hdmi->hdcp_ctrl = hdmi_hdcp_init(hdmi);
 234         if (IS_ERR(hdmi->hdcp_ctrl)) {
 235                 dev_warn(&pdev->dev, "failed to init hdcp: disabled\n");
 236                 hdmi->hdcp_ctrl = NULL;
 237         }
 238
 239         return hdmi;
 240
 241 fail:
 242         if (hdmi)
 243                 hdmi_destroy(hdmi);
 244
 245         return ERR_PTR(ret);
 246 }
 247
 248 /* Second part of initialization, the drm/kms level modeset_init,
 249  * constructs/initializes mode objects, etc, is called from master
 250  * driver (not hdmi sub-device's probe/bind!)
 251  *
 252  * Any resource (regulator/clk/etc) which could be missing at boot
 253  * should be handled in hdmi_init() so that failure happens from
 254  * hdmi sub-device's probe.
 255  */
 256 int hdmi_modeset_init(struct hdmi *hdmi,
 257                 struct drm_device *dev, struct drm_encoder *encoder)
 258 {
 259         struct msm_drm_private *priv = dev->dev_private;
 260         struct platform_device *pdev = hdmi->pdev;
 261         int ret;
 262
 263         hdmi->dev = dev;
 264         hdmi->encoder = encoder;
 265
 266         hdmi_audio_infoframe_init(&hdmi->audio.infoframe);
 267
 268         hdmi->bridge = hdmi_bridge_init(hdmi);
 269         if (IS_ERR(hdmi->bridge)) {
 270                 ret = PTR_ERR(hdmi->bridge);
 271                 dev_err(dev->dev, "failed to create HDMI bridge: %d\n", ret);
 272                 hdmi->bridge = NULL;
 273                 goto fail;
 274         }
 275
 276         hdmi->connector = hdmi_connector_init(hdmi);
 277         if (IS_ERR(hdmi->connector)) {
 278                 ret = PTR_ERR(hdmi->connector);
 279                 dev_err(dev->dev, "failed to create HDMI connector: %d\n", ret);
 280                 hdmi->connector = NULL;
 281                 goto fail;
 282         }
 283
 284         hdmi->irq = irq_of_parse_and_map(pdev->dev.of_node, 0);
 285         if (hdmi->irq < 0) {
 286                 ret = hdmi->irq;
 287                 dev_err(dev->dev, "failed to get irq: %d\n", ret);
 288                 goto fail;
 289         }
 290
 291         ret = devm_request_irq(&pdev->dev, hdmi->irq,
 292                         hdmi_irq, IRQF_TRIGGER_HIGH | IRQF_ONESHOT,
 293                         "hdmi_isr", hdmi);
 294         if (ret < 0) {
 295                 dev_err(dev->dev, "failed to request IRQ%u: %d\n",
 296                                 hdmi->irq, ret);
 297                 goto fail;
 298         }
 299
 300         encoder->bridge = hdmi->bridge;
 301
 302         priv->bridges[priv->num_bridges++]       = hdmi->bridge;
 303         priv->connectors[priv->num_connectors++] = hdmi->connector;
 304
 305         platform_set_drvdata(pdev, hdmi);
 306
 307         return 0;
 308
 309 fail:
 310         /* bridge is normally destroyed by drm: */
 311         if (hdmi->bridge) {
 312                 hdmi_bridge_destroy(hdmi->bridge);
 313                 hdmi->bridge = NULL;
 314         }
 315         if (hdmi->connector) {
 316                 hdmi->connector->funcs->destroy(hdmi->connector);
 317                 hdmi->connector = NULL;
 318         }
 319
 320         return ret;
 321 }
 322
 323 /*
 324  * The hdmi device:
 325  */
 326
 327 #define HDMI_CFG(item, entry) \
 328         .item ## _names = item ##_names_ ## entry, \
 329         .item ## _cnt   = ARRAY_SIZE(item ## _names_ ## entry)
 330
 331 static const char *pwr_reg_names_none[] = {};
 332 static const char *hpd_reg_names_none[] = {};
 333
 334 static struct hdmi_platform_config hdmi_tx_8660_config = {
 335                 .phy_init = hdmi_phy_8x60_init,
 336 };
 337
 338 static const char *hpd_reg_names_8960[] = {"core-vdda", "hdmi-mux"};
 339 static const char *hpd_clk_names_8960[] = {"core_clk", "master_iface_clk", "slave_iface_clk"};
 340
 341 static struct hdmi_platform_config hdmi_tx_8960_config = {
 342                 .phy_init = hdmi_phy_8960_init,
 343                 HDMI_CFG(hpd_reg, 8960),
 344                 HDMI_CFG(hpd_clk, 8960),
 345 };
 346
 347 static const char *pwr_reg_names_8x74[] = {"core-vdda", "core-vcc"};
 348 static const char *hpd_reg_names_8x74[] = {"hpd-gdsc", "hpd-5v"};
 349 static const char *pwr_clk_names_8x74[] = {"extp_clk", "alt_iface_clk"};
 350 static const char *hpd_clk_names_8x74[] = {"iface_clk", "core_clk", "mdp_core_clk"};
 351 static unsigned long hpd_clk_freq_8x74[] = {0, 19200000, 0};
 352
 353 static struct hdmi_platform_config hdmi_tx_8974_config = {
 354                 .phy_init = hdmi_phy_8x74_init,
 355                 HDMI_CFG(pwr_reg, 8x74),
 356                 HDMI_CFG(hpd_reg, 8x74),
 357                 HDMI_CFG(pwr_clk, 8x74),
 358                 HDMI_CFG(hpd_clk, 8x74),
 359                 .hpd_freq      = hpd_clk_freq_8x74,
 360 };
 361
 362 static const char *hpd_reg_names_8084[] = {"hpd-gdsc", "hpd-5v", "hpd-5v-en"};
 363
 364 static struct hdmi_platform_config hdmi_tx_8084_config = {
 365                 .phy_init = hdmi_phy_8x74_init,
 366                 HDMI_CFG(pwr_reg, 8x74),
 367                 HDMI_CFG(hpd_reg, 8084),
 368                 HDMI_CFG(pwr_clk, 8x74),
 369                 HDMI_CFG(hpd_clk, 8x74),
 370                 .hpd_freq      = hpd_clk_freq_8x74,
 371 };
 372
 373 static struct hdmi_platform_config hdmi_tx_8994_config = {
 374                 .phy_init = NULL, /* nothing to do for this HDMI PHY 20nm */
 375                 HDMI_CFG(pwr_reg, 8x74),
 376                 HDMI_CFG(hpd_reg, none),
 377                 HDMI_CFG(pwr_clk, 8x74),
 378                 HDMI_CFG(hpd_clk, 8x74),
 379                 .hpd_freq      = hpd_clk_freq_8x74,
 380 };
 381
 382 static struct hdmi_platform_config hdmi_tx_8996_config = {
 383                 .phy_init = NULL,
 384                 HDMI_CFG(pwr_reg, none),
 385                 HDMI_CFG(hpd_reg, none),
 386                 HDMI_CFG(pwr_clk, 8x74),
 387                 HDMI_CFG(hpd_clk, 8x74),
 388                 .hpd_freq      = hpd_clk_freq_8x74,
 389 };
 390
 391 static int get_gpio(struct device *dev, struct device_node *of_node, const char *name)
 392 {
 393         int gpio = of_get_named_gpio(of_node, name, 0);
 394         if (gpio < 0) {
 395                 char name2[32];
 396                 snprintf(name2, sizeof(name2), "%s-gpio", name);
 397                 gpio = of_get_named_gpio(of_node, name2, 0);
 398                 if (gpio < 0) {
 399                         DBG("failed to get gpio: %s (%d)", name, gpio);
 400                         gpio = -1;
 401                 }
 402         }
 403         return gpio;
 404 }
 405
 406 static int hdmi_bind(struct device *dev, struct device *master, void *data)
 407 {
 408         struct drm_device *drm = dev_get_drvdata(master);
 409         struct msm_drm_private *priv = drm->dev_private;
 410         static struct hdmi_platform_config *hdmi_cfg;
 411         struct hdmi *hdmi;
 412         struct device_node *of_node = dev->of_node;
 413
 414         hdmi_cfg = (struct hdmi_platform_config *)
 415                         of_device_get_match_data(dev);
 416         if (!hdmi_cfg) {
 417                 dev_err(dev, "unknown hdmi_cfg: %s\n", of_node->name);
 418                 return -ENXIO;
 419         }
 420
 421         hdmi_cfg->mmio_name     = "core_physical";
 422         hdmi_cfg->qfprom_mmio_name = "qfprom_physical";
 423         hdmi_cfg->ddc_clk_gpio  = get_gpio(dev, of_node, "qcom,hdmi-tx-ddc-clk");
 424         hdmi_cfg->ddc_data_gpio = get_gpio(dev, of_node, "qcom,hdmi-tx-ddc-data");
 425         hdmi_cfg->hpd_gpio      = get_gpio(dev, of_node, "qcom,hdmi-tx-hpd");
 426         hdmi_cfg->mux_en_gpio   = get_gpio(dev, of_node, "qcom,hdmi-tx-mux-en");
 427         hdmi_cfg->mux_sel_gpio  = get_gpio(dev, of_node, "qcom,hdmi-tx-mux-sel");
 428         hdmi_cfg->mux_lpm_gpio  = get_gpio(dev, of_node, "qcom,hdmi-tx-mux-lpm");
 429
 430         dev->platform_data = hdmi_cfg;
 431
 432         hdmi = hdmi_init(to_platform_device(dev));
 433         if (IS_ERR(hdmi))
 434                 return PTR_ERR(hdmi);
 435         priv->hdmi = hdmi;
 436
 437         return 0;
 438 }
 439
 440 static void hdmi_unbind(struct device *dev, struct device *master,
 441                 void *data)
 442 {
 443         struct drm_device *drm = dev_get_drvdata(master);
 444         struct msm_drm_private *priv = drm->dev_private;
 445         if (priv->hdmi) {
 446                 hdmi_destroy(priv->hdmi);
 447                 priv->hdmi = NULL;
 448         }
 449 }
 450
 451 static const struct component_ops hdmi_ops = {
 452                 .bind   = hdmi_bind,
 453                 .unbind = hdmi_unbind,
 454 };
 455
 456 static int hdmi_dev_probe(struct platform_device *pdev)
 457 {
 458         return component_add(&pdev->dev, &hdmi_ops);
 459 }
 460
 461 static int hdmi_dev_remove(struct platform_device *pdev)
 462 {
 463         component_del(&pdev->dev, &hdmi_ops);
 464         return 0;
 465 }
 466
 467 static const struct of_device_id dt_match[] = {
 468         { .compatible = "qcom,hdmi-tx-8996", .data = &hdmi_tx_8996_config },
 469         { .compatible = "qcom,hdmi-tx-8994", .data = &hdmi_tx_8994_config },
 470         { .compatible = "qcom,hdmi-tx-8084", .data = &hdmi_tx_8084_config },
 471         { .compatible = "qcom,hdmi-tx-8974", .data = &hdmi_tx_8974_config },
 472         { .compatible = "qcom,hdmi-tx-8960", .data = &hdmi_tx_8960_config },
 473         { .compatible = "qcom,hdmi-tx-8660", .data = &hdmi_tx_8660_config },
 474         {}
 475 };
 476
 477 static struct platform_driver hdmi_driver = {
 478         .probe = hdmi_dev_probe,
 479         .remove = hdmi_dev_remove,
 480         .driver = {
 481                 .name = "hdmi_msm",
 482                 .of_match_table = dt_match,
 483         },
 484 };
 485
 486 void __init hdmi_register(void)
 487 {
 488         platform_driver_register(&hdmi_driver);
 489 }
 490
 491 void __exit hdmi_unregister(void)
 492 {
 493         platform_driver_unregister(&hdmi_driver);
 494 }