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

   1 /*
   2  * Copyright (C) 2013 Red Hat
   3  * Author: Rob Clark <robdclark@gmail.com>
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 as published by
   7  * the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  12  * more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along with
  15  * this program.  If not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 #include <linux/gpio.h>
  19
  20 #include "msm_kms.h"
  21 #include "hdmi.h"
  22
  23 struct hdmi_connector {
  24         struct drm_connector base;
  25         struct hdmi *hdmi;
  26         struct work_struct hpd_work;
  27 };
  28 #define to_hdmi_connector(x) container_of(x, struct hdmi_connector, base)
  29
  30 static int gpio_config(struct hdmi *hdmi, bool on)
  31 {
  32         struct drm_device *dev = hdmi->dev;
  33         const struct hdmi_platform_config *config = hdmi->config;
  34         int ret;
  35
  36         if (on) {
  37                 ret = gpio_request(config->ddc_clk_gpio, "HDMI_DDC_CLK");
  38                 if (ret) {
  39                         dev_err(dev->dev, "'%s'(%d) gpio_request failed: %d\n",
  40                                 "HDMI_DDC_CLK", config->ddc_clk_gpio, ret);
  41                         goto error1;
  42                 }
  43                 gpio_set_value_cansleep(config->ddc_clk_gpio, 1);
  44
  45                 ret = gpio_request(config->ddc_data_gpio, "HDMI_DDC_DATA");
  46                 if (ret) {
  47                         dev_err(dev->dev, "'%s'(%d) gpio_request failed: %d\n",
  48                                 "HDMI_DDC_DATA", config->ddc_data_gpio, ret);
  49                         goto error2;
  50                 }
  51                 gpio_set_value_cansleep(config->ddc_data_gpio, 1);
  52
  53                 ret = gpio_request(config->hpd_gpio, "HDMI_HPD");
  54                 if (ret) {
  55                         dev_err(dev->dev, "'%s'(%d) gpio_request failed: %d\n",
  56                                 "HDMI_HPD", config->hpd_gpio, ret);
  57                         goto error3;
  58                 }
  59                 gpio_direction_input(config->hpd_gpio);
  60                 gpio_set_value_cansleep(config->hpd_gpio, 1);
  61
  62                 if (config->mux_en_gpio != -1) {
  63                         ret = gpio_request(config->mux_en_gpio, "HDMI_MUX_EN");
  64                         if (ret) {
  65                                 dev_err(dev->dev, "'%s'(%d) gpio_request failed: %d\n",
  66                                         "HDMI_MUX_SEL", config->mux_en_gpio, ret);
  67                                 goto error4;
  68                         }
  69                         gpio_set_value_cansleep(config->mux_en_gpio, 1);
  70                 }
  71
  72                 if (config->mux_sel_gpio != -1) {
  73                         ret = gpio_request(config->mux_sel_gpio, "HDMI_MUX_SEL");
  74                         if (ret) {
  75                                 dev_err(dev->dev, "'%s'(%d) gpio_request failed: %d\n",
  76                                         "HDMI_MUX_SEL", config->mux_sel_gpio, ret);
  77                                 goto error5;
  78                         }
  79                         gpio_set_value_cansleep(config->mux_sel_gpio, 0);
  80                 }
  81                 DBG("gpio on");
  82         } else {
  83                 gpio_free(config->ddc_clk_gpio);
  84                 gpio_free(config->ddc_data_gpio);
  85                 gpio_free(config->hpd_gpio);
  86
  87                 if (config->mux_en_gpio != -1) {
  88                         gpio_set_value_cansleep(config->mux_en_gpio, 0);
  89                         gpio_free(config->mux_en_gpio);
  90                 }
  91
  92                 if (config->mux_sel_gpio != -1) {
  93                         gpio_set_value_cansleep(config->mux_sel_gpio, 1);
  94                         gpio_free(config->mux_sel_gpio);
  95                 }
  96                 DBG("gpio off");
  97         }
  98
  99         return 0;
 100
 101 error5:
 102         if (config->mux_en_gpio != -1)
 103                 gpio_free(config->mux_en_gpio);
 104 error4:
 105         gpio_free(config->hpd_gpio);
 106 error3:
 107         gpio_free(config->ddc_data_gpio);
 108 error2:
 109         gpio_free(config->ddc_clk_gpio);
 110 error1:
 111         return ret;
 112 }
 113
 114 static int hpd_enable(struct hdmi_connector *hdmi_connector)
 115 {
 116         struct hdmi *hdmi = hdmi_connector->hdmi;
 117         const struct hdmi_platform_config *config = hdmi->config;
 118         struct drm_device *dev = hdmi_connector->base.dev;
 119         struct hdmi_phy *phy = hdmi->phy;
 120         uint32_t hpd_ctrl;
 121         int i, ret;
 122
 123         ret = gpio_config(hdmi, true);
 124         if (ret) {
 125                 dev_err(dev->dev, "failed to configure GPIOs: %d\n", ret);
 126                 goto fail;
 127         }
 128
 129         for (i = 0; i < config->hpd_clk_cnt; i++) {
 130                 ret = clk_prepare_enable(hdmi->hpd_clks[i]);
 131                 if (ret) {
 132                         dev_err(dev->dev, "failed to enable hpd clk: %s (%d)\n",
 133                                         config->hpd_clk_names[i], ret);
 134                         goto fail;
 135                 }
 136         }
 137
 138         for (i = 0; i < config->hpd_reg_cnt; i++) {
 139                 ret = regulator_enable(hdmi->hpd_regs[i]);
 140                 if (ret) {
 141                         dev_err(dev->dev, "failed to enable hpd regulator: %s (%d)\n",
 142                                         config->hpd_reg_names[i], ret);
 143                         goto fail;
 144                 }
 145         }
 146
 147         hdmi_set_mode(hdmi, false);
 148         phy->funcs->reset(phy);
 149         hdmi_set_mode(hdmi, true);
 150
 151         hdmi_write(hdmi, REG_HDMI_USEC_REFTIMER, 0x0001001b);
 152
 153         /* enable HPD events: */
 154         hdmi_write(hdmi, REG_HDMI_HPD_INT_CTRL,
 155                         HDMI_HPD_INT_CTRL_INT_CONNECT |
 156                         HDMI_HPD_INT_CTRL_INT_EN);
 157
 158         /* set timeout to 4.1ms (max) for hardware debounce */
 159         hpd_ctrl = hdmi_read(hdmi, REG_HDMI_HPD_CTRL);
 160         hpd_ctrl |= HDMI_HPD_CTRL_TIMEOUT(0x1fff);
 161
 162         /* Toggle HPD circuit to trigger HPD sense */
 163         hdmi_write(hdmi, REG_HDMI_HPD_CTRL,
 164                         ~HDMI_HPD_CTRL_ENABLE & hpd_ctrl);
 165         hdmi_write(hdmi, REG_HDMI_HPD_CTRL,
 166                         HDMI_HPD_CTRL_ENABLE | hpd_ctrl);
 167
 168         return 0;
 169
 170 fail:
 171         return ret;
 172 }
 173
 174 static int hdp_disable(struct hdmi_connector *hdmi_connector)
 175 {
 176         struct hdmi *hdmi = hdmi_connector->hdmi;
 177         const struct hdmi_platform_config *config = hdmi->config;
 178         struct drm_device *dev = hdmi_connector->base.dev;
 179         int i, ret = 0;
 180
 181         /* Disable HPD interrupt */
 182         hdmi_write(hdmi, REG_HDMI_HPD_INT_CTRL, 0);
 183
 184         hdmi_set_mode(hdmi, false);
 185
 186         for (i = 0; i < config->hpd_reg_cnt; i++) {
 187                 ret = regulator_disable(hdmi->hpd_regs[i]);
 188                 if (ret) {
 189                         dev_err(dev->dev, "failed to disable hpd regulator: %s (%d)\n",
 190                                         config->hpd_reg_names[i], ret);
 191                         goto fail;
 192                 }
 193         }
 194
 195         for (i = 0; i < config->hpd_clk_cnt; i++)
 196                 clk_disable_unprepare(hdmi->hpd_clks[i]);
 197
 198         ret = gpio_config(hdmi, false);
 199         if (ret) {
 200                 dev_err(dev->dev, "failed to unconfigure GPIOs: %d\n", ret);
 201                 goto fail;
 202         }
 203
 204         return 0;
 205
 206 fail:
 207         return ret;
 208 }
 209
 210 static void
 211 hotplug_work(struct work_struct *work)
 212 {
 213         struct hdmi_connector *hdmi_connector =
 214                 container_of(work, struct hdmi_connector, hpd_work);
 215         struct drm_connector *connector = &hdmi_connector->base;
 216         drm_helper_hpd_irq_event(connector->dev);
 217 }
 218
 219 void hdmi_connector_irq(struct drm_connector *connector)
 220 {
 221         struct hdmi_connector *hdmi_connector = to_hdmi_connector(connector);
 222         struct msm_drm_private *priv = connector->dev->dev_private;
 223         struct hdmi *hdmi = hdmi_connector->hdmi;
 224         uint32_t hpd_int_status, hpd_int_ctrl;
 225
 226         /* Process HPD: */
 227         hpd_int_status = hdmi_read(hdmi, REG_HDMI_HPD_INT_STATUS);
 228         hpd_int_ctrl   = hdmi_read(hdmi, REG_HDMI_HPD_INT_CTRL);
 229
 230         if ((hpd_int_ctrl & HDMI_HPD_INT_CTRL_INT_EN) &&
 231                         (hpd_int_status & HDMI_HPD_INT_STATUS_INT)) {
 232                 bool detected = !!(hpd_int_status & HDMI_HPD_INT_STATUS_CABLE_DETECTED);
 233
 234                 DBG("status=%04x, ctrl=%04x", hpd_int_status, hpd_int_ctrl);
 235
 236                 /* ack the irq: */
 237                 hdmi_write(hdmi, REG_HDMI_HPD_INT_CTRL,
 238                                 hpd_int_ctrl | HDMI_HPD_INT_CTRL_INT_ACK);
 239
 240                 /* detect disconnect if we are connected or visa versa: */
 241                 hpd_int_ctrl = HDMI_HPD_INT_CTRL_INT_EN;
 242                 if (!detected)
 243                         hpd_int_ctrl |= HDMI_HPD_INT_CTRL_INT_CONNECT;
 244                 hdmi_write(hdmi, REG_HDMI_HPD_INT_CTRL, hpd_int_ctrl);
 245
 246                 queue_work(priv->wq, &hdmi_connector->hpd_work);
 247         }
 248 }
 249
 250 static enum drm_connector_status detect_reg(struct hdmi *hdmi)
 251 {
 252         uint32_t hpd_int_status = hdmi_read(hdmi, REG_HDMI_HPD_INT_STATUS);
 253         return (hpd_int_status & HDMI_HPD_INT_STATUS_CABLE_DETECTED) ?
 254                         connector_status_connected : connector_status_disconnected;
 255 }
 256
 257 static enum drm_connector_status detect_gpio(struct hdmi *hdmi)
 258 {
 259         const struct hdmi_platform_config *config = hdmi->config;
 260         return gpio_get_value(config->hpd_gpio) ?
 261                         connector_status_connected :
 262                         connector_status_disconnected;
 263 }
 264
 265 static enum drm_connector_status hdmi_connector_detect(
 266                 struct drm_connector *connector, bool force)
 267 {
 268         struct hdmi_connector *hdmi_connector = to_hdmi_connector(connector);
 269         struct hdmi *hdmi = hdmi_connector->hdmi;
 270         enum drm_connector_status stat_gpio, stat_reg;
 271         int retry = 20;
 272
 273         do {
 274                 stat_gpio = detect_gpio(hdmi);
 275                 stat_reg  = detect_reg(hdmi);
 276
 277                 if (stat_gpio == stat_reg)
 278                         break;
 279
 280                 mdelay(10);
 281         } while (--retry);
 282
 283         /* the status we get from reading gpio seems to be more reliable,
 284          * so trust that one the most if we didn't manage to get hdmi and
 285          * gpio status to agree:
 286          */
 287         if (stat_gpio != stat_reg) {
 288                 DBG("HDMI_HPD_INT_STATUS tells us: %d", stat_reg);
 289                 DBG("hpd gpio tells us: %d", stat_gpio);
 290         }
 291
 292         return stat_gpio;
 293 }
 294
 295 static void hdmi_connector_destroy(struct drm_connector *connector)
 296 {
 297         struct hdmi_connector *hdmi_connector = to_hdmi_connector(connector);
 298
 299         hdp_disable(hdmi_connector);
 300
 301         drm_connector_unregister(connector);
 302         drm_connector_cleanup(connector);
 303
 304         hdmi_unreference(hdmi_connector->hdmi);
 305
 306         kfree(hdmi_connector);
 307 }
 308
 309 static int hdmi_connector_get_modes(struct drm_connector *connector)
 310 {
 311         struct hdmi_connector *hdmi_connector = to_hdmi_connector(connector);
 312         struct hdmi *hdmi = hdmi_connector->hdmi;
 313         struct edid *edid;
 314         uint32_t hdmi_ctrl;
 315         int ret = 0;
 316
 317         hdmi_ctrl = hdmi_read(hdmi, REG_HDMI_CTRL);
 318         hdmi_write(hdmi, REG_HDMI_CTRL, hdmi_ctrl | HDMI_CTRL_ENABLE);
 319
 320         edid = drm_get_edid(connector, hdmi->i2c);
 321
 322         hdmi_write(hdmi, REG_HDMI_CTRL, hdmi_ctrl);
 323
 324         drm_mode_connector_update_edid_property(connector, edid);
 325
 326         if (edid) {
 327                 ret = drm_add_edid_modes(connector, edid);
 328                 kfree(edid);
 329         }
 330
 331         return ret;
 332 }
 333
 334 static int hdmi_connector_mode_valid(struct drm_connector *connector,
 335                                  struct drm_display_mode *mode)
 336 {
 337         struct hdmi_connector *hdmi_connector = to_hdmi_connector(connector);
 338         struct hdmi *hdmi = hdmi_connector->hdmi;
 339         const struct hdmi_platform_config *config = hdmi->config;
 340         struct msm_drm_private *priv = connector->dev->dev_private;
 341         struct msm_kms *kms = priv->kms;
 342         long actual, requested;
 343
 344         requested = 1000 * mode->clock;
 345         actual = kms->funcs->round_pixclk(kms,
 346                         requested, hdmi_connector->hdmi->encoder);
 347
 348         /* for mdp5/apq8074, we manage our own pixel clk (as opposed to
 349          * mdp4/dtv stuff where pixel clk is assigned to mdp/encoder
 350          * instead):
 351          */
 352         if (config->pwr_clk_cnt > 0)
 353                 actual = clk_round_rate(hdmi->pwr_clks[0], actual);
 354
 355         DBG("requested=%ld, actual=%ld", requested, actual);
 356
 357         if (actual != requested)
 358                 return MODE_CLOCK_RANGE;
 359
 360         return 0;
 361 }
 362
 363 static struct drm_encoder *
 364 hdmi_connector_best_encoder(struct drm_connector *connector)
 365 {
 366         struct hdmi_connector *hdmi_connector = to_hdmi_connector(connector);
 367         return hdmi_connector->hdmi->encoder;
 368 }
 369
 370 static const struct drm_connector_funcs hdmi_connector_funcs = {
 371         .dpms = drm_helper_connector_dpms,
 372         .detect = hdmi_connector_detect,
 373         .fill_modes = drm_helper_probe_single_connector_modes,
 374         .destroy = hdmi_connector_destroy,
 375 };
 376
 377 static const struct drm_connector_helper_funcs hdmi_connector_helper_funcs = {
 378         .get_modes = hdmi_connector_get_modes,
 379         .mode_valid = hdmi_connector_mode_valid,
 380         .best_encoder = hdmi_connector_best_encoder,
 381 };
 382
 383 /* initialize connector */
 384 struct drm_connector *hdmi_connector_init(struct hdmi *hdmi)
 385 {
 386         struct drm_connector *connector = NULL;
 387         struct hdmi_connector *hdmi_connector;
 388         int ret;
 389
 390         hdmi_connector = kzalloc(sizeof(*hdmi_connector), GFP_KERNEL);
 391         if (!hdmi_connector) {
 392                 ret = -ENOMEM;
 393                 goto fail;
 394         }
 395
 396         hdmi_connector->hdmi = hdmi_reference(hdmi);
 397         INIT_WORK(&hdmi_connector->hpd_work, hotplug_work);
 398
 399         connector = &hdmi_connector->base;
 400
 401         drm_connector_init(hdmi->dev, connector, &hdmi_connector_funcs,
 402                         DRM_MODE_CONNECTOR_HDMIA);
 403         drm_connector_helper_add(connector, &hdmi_connector_helper_funcs);
 404
 405         connector->polled = DRM_CONNECTOR_POLL_CONNECT |
 406                         DRM_CONNECTOR_POLL_DISCONNECT;
 407
 408         connector->interlace_allowed = 1;
 409         connector->doublescan_allowed = 0;
 410
 411         drm_connector_register(connector);
 412
 413         ret = hpd_enable(hdmi_connector);
 414         if (ret) {
 415                 dev_err(hdmi->dev->dev, "failed to enable HPD: %d\n", ret);
 416                 goto fail;
 417         }
 418
 419         drm_mode_connector_attach_encoder(connector, hdmi->encoder);
 420
 421         return connector;
 422
 423 fail:
 424         if (connector)
 425                 hdmi_connector_destroy(connector);
 426
 427         return ERR_PTR(ret);
 428 }