drivers/gpu/drm/loongson/lsdc_output_7a2000.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (C) 2023 Loongson Technology Corporation Limited
   4  */
   5
   6 #include <linux/delay.h>
   7
   8 #include <drm/drm_atomic_helper.h>
   9 #include <drm/drm_debugfs.h>
  10 #include <drm/drm_edid.h>
  11 #include <drm/drm_probe_helper.h>
  12
  13 #include "lsdc_drv.h"
  14 #include "lsdc_output.h"
  15
  16 /*
  17  * The display controller in LS7A2000 has two display pipes
  18  * Display pipe 0 is attached with a built-in transparent VGA encoder and
  19  * a built-in HDMI encoder.
  20  * Display pipe 1 has only one built-in HDMI encoder connected.
  21  *       ______________________                          _____________
  22  *      |             +-----+  |                        |             |
  23  *      | CRTC0 -+--> | VGA |  ----> VGA Connector ---> | VGA Monitor |<---+
  24  *      |        |    +-----+  |                        |_____________|    |
  25  *      |        |             |                         ______________    |
  26  *      |        |    +------+ |                        |              |   |
  27  *      |        +--> | HDMI | ----> HDMI Connector --> | HDMI Monitor |<--+
  28  *      |             +------+ |                        |______________|   |
  29  *      |            +------+  |                                           |
  30  *      |            | i2c6 |  <-------------------------------------------+
  31  *      |            +------+  |
  32  *      |                      |
  33  *      |    DC in LS7A2000    |
  34  *      |                      |
  35  *      |            +------+  |
  36  *      |            | i2c7 |  <--------------------------------+
  37  *      |            +------+  |                                |
  38  *      |                      |                          ______|_______
  39  *      |            +------+  |                         |              |
  40  *      | CRTC1 ---> | HDMI |  ----> HDMI Connector ---> | HDMI Monitor |
  41  *      |            +------+  |                         |______________|
  42  *      |______________________|
  43  */
  44
  45 static int ls7a2000_connector_get_modes(struct drm_connector *connector)
  46 {
  47         unsigned int num = 0;
  48         struct edid *edid;
  49
  50         if (connector->ddc) {
  51                 edid = drm_get_edid(connector, connector->ddc);
  52                 if (edid) {
  53                         drm_connector_update_edid_property(connector, edid);
  54                         num = drm_add_edid_modes(connector, edid);
  55                         kfree(edid);
  56                 }
  57
  58                 return num;
  59         }
  60
  61         num = drm_add_modes_noedid(connector, 1920, 1200);
  62
  63         drm_set_preferred_mode(connector, 1024, 768);
  64
  65         return num;
  66 }
  67
  68 static struct drm_encoder *
  69 ls7a2000_connector_get_best_encoder(struct drm_connector *connector,
  70                                     struct drm_atomic_state *state)
  71 {
  72         struct lsdc_output *output = connector_to_lsdc_output(connector);
  73
  74         return &output->encoder;
  75 }
  76
  77 static const struct drm_connector_helper_funcs ls7a2000_connector_helpers = {
  78         .atomic_best_encoder = ls7a2000_connector_get_best_encoder,
  79         .get_modes = ls7a2000_connector_get_modes,
  80 };
  81
  82 /* debugfs */
  83
  84 #define LSDC_HDMI_REG(i, reg) {                               \
  85         .name = __stringify_1(LSDC_HDMI##i##_##reg##_REG),    \
  86         .offset = LSDC_HDMI##i##_##reg##_REG,                 \
  87 }
  88
  89 static const struct lsdc_reg32 ls7a2000_hdmi0_encoder_regs[] = {
  90         LSDC_HDMI_REG(0, ZONE),
  91         LSDC_HDMI_REG(0, INTF_CTRL),
  92         LSDC_HDMI_REG(0, PHY_CTRL),
  93         LSDC_HDMI_REG(0, PHY_PLL),
  94         LSDC_HDMI_REG(0, AVI_INFO_CRTL),
  95         LSDC_HDMI_REG(0, PHY_CAL),
  96         LSDC_HDMI_REG(0, AUDIO_PLL_LO),
  97         LSDC_HDMI_REG(0, AUDIO_PLL_HI),
  98         {NULL, 0},  /* MUST be {NULL, 0} terminated */
  99 };
 100
 101 static const struct lsdc_reg32 ls7a2000_hdmi1_encoder_regs[] = {
 102         LSDC_HDMI_REG(1, ZONE),
 103         LSDC_HDMI_REG(1, INTF_CTRL),
 104         LSDC_HDMI_REG(1, PHY_CTRL),
 105         LSDC_HDMI_REG(1, PHY_PLL),
 106         LSDC_HDMI_REG(1, AVI_INFO_CRTL),
 107         LSDC_HDMI_REG(1, PHY_CAL),
 108         LSDC_HDMI_REG(1, AUDIO_PLL_LO),
 109         LSDC_HDMI_REG(1, AUDIO_PLL_HI),
 110         {NULL, 0},  /* MUST be {NULL, 0} terminated */
 111 };
 112
 113 static int ls7a2000_hdmi_encoder_regs_show(struct seq_file *m, void *data)
 114 {
 115         struct drm_info_node *node = (struct drm_info_node *)m->private;
 116         struct drm_device *ddev = node->minor->dev;
 117         struct lsdc_device *ldev = to_lsdc(ddev);
 118         const struct lsdc_reg32 *preg;
 119
 120         preg = (const struct lsdc_reg32 *)node->info_ent->data;
 121
 122         while (preg->name) {
 123                 u32 offset = preg->offset;
 124
 125                 seq_printf(m, "%s (0x%04x): 0x%08x\n",
 126                            preg->name, offset, lsdc_rreg32(ldev, offset));
 127                 ++preg;
 128         }
 129
 130         return 0;
 131 }
 132
 133 static const struct drm_info_list ls7a2000_hdmi0_debugfs_files[] = {
 134         { "regs", ls7a2000_hdmi_encoder_regs_show, 0, (void *)ls7a2000_hdmi0_encoder_regs },
 135 };
 136
 137 static const struct drm_info_list ls7a2000_hdmi1_debugfs_files[] = {
 138         { "regs", ls7a2000_hdmi_encoder_regs_show, 0, (void *)ls7a2000_hdmi1_encoder_regs },
 139 };
 140
 141 static void ls7a2000_hdmi0_late_register(struct drm_connector *connector,
 142                                          struct dentry *root)
 143 {
 144         struct drm_device *ddev = connector->dev;
 145         struct drm_minor *minor = ddev->primary;
 146
 147         drm_debugfs_create_files(ls7a2000_hdmi0_debugfs_files,
 148                                  ARRAY_SIZE(ls7a2000_hdmi0_debugfs_files),
 149                                  root, minor);
 150 }
 151
 152 static void ls7a2000_hdmi1_late_register(struct drm_connector *connector,
 153                                          struct dentry *root)
 154 {
 155         struct drm_device *ddev = connector->dev;
 156         struct drm_minor *minor = ddev->primary;
 157
 158         drm_debugfs_create_files(ls7a2000_hdmi1_debugfs_files,
 159                                  ARRAY_SIZE(ls7a2000_hdmi1_debugfs_files),
 160                                  root, minor);
 161 }
 162
 163 /* monitor present detection */
 164
 165 static enum drm_connector_status
 166 ls7a2000_hdmi0_vga_connector_detect(struct drm_connector *connector, bool force)
 167 {
 168         struct drm_device *ddev = connector->dev;
 169         struct lsdc_device *ldev = to_lsdc(ddev);
 170         u32 val;
 171
 172         val = lsdc_rreg32(ldev, LSDC_HDMI_HPD_STATUS_REG);
 173
 174         if (val & HDMI0_HPD_FLAG)
 175                 return connector_status_connected;
 176
 177         if (connector->ddc) {
 178                 if (drm_probe_ddc(connector->ddc))
 179                         return connector_status_connected;
 180
 181                 return connector_status_disconnected;
 182         }
 183
 184         return connector_status_unknown;
 185 }
 186
 187 static enum drm_connector_status
 188 ls7a2000_hdmi1_connector_detect(struct drm_connector *connector, bool force)
 189 {
 190         struct lsdc_device *ldev = to_lsdc(connector->dev);
 191         u32 val;
 192
 193         val = lsdc_rreg32(ldev, LSDC_HDMI_HPD_STATUS_REG);
 194
 195         if (val & HDMI1_HPD_FLAG)
 196                 return connector_status_connected;
 197
 198         return connector_status_disconnected;
 199 }
 200
 201 static const struct drm_connector_funcs ls7a2000_hdmi_connector_funcs[2] = {
 202         {
 203                 .detect = ls7a2000_hdmi0_vga_connector_detect,
 204                 .fill_modes = drm_helper_probe_single_connector_modes,
 205                 .destroy = drm_connector_cleanup,
 206                 .reset = drm_atomic_helper_connector_reset,
 207                 .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
 208                 .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
 209                 .debugfs_init = ls7a2000_hdmi0_late_register,
 210         },
 211         {
 212                 .detect = ls7a2000_hdmi1_connector_detect,
 213                 .fill_modes = drm_helper_probe_single_connector_modes,
 214                 .destroy = drm_connector_cleanup,
 215                 .reset = drm_atomic_helper_connector_reset,
 216                 .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
 217                 .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
 218                 .debugfs_init = ls7a2000_hdmi1_late_register,
 219         },
 220 };
 221
 222 /* Even though some board has only one hdmi on display pipe 1,
 223  * We still need hook lsdc_encoder_funcs up on display pipe 0,
 224  * This is because we need its reset() callback get called, to
 225  * set the LSDC_HDMIx_CTRL_REG using software gpio emulated i2c.
 226  * Otherwise, the firmware may set LSDC_HDMIx_CTRL_REG blindly.
 227  */
 228 static void ls7a2000_hdmi0_encoder_reset(struct drm_encoder *encoder)
 229 {
 230         struct drm_device *ddev = encoder->dev;
 231         struct lsdc_device *ldev = to_lsdc(ddev);
 232         u32 val;
 233
 234         val = PHY_CLOCK_POL | PHY_CLOCK_EN | PHY_DATA_EN;
 235         lsdc_wreg32(ldev, LSDC_CRTC0_DVO_CONF_REG, val);
 236
 237         /* using software gpio emulated i2c */
 238         val = lsdc_rreg32(ldev, LSDC_HDMI0_INTF_CTRL_REG);
 239         val &= ~HW_I2C_EN;
 240         lsdc_wreg32(ldev, LSDC_HDMI0_INTF_CTRL_REG, val);
 241
 242         /* help the hdmi phy to get out of reset state */
 243         lsdc_wreg32(ldev, LSDC_HDMI0_PHY_CTRL_REG, HDMI_PHY_RESET_N);
 244
 245         mdelay(20);
 246
 247         drm_dbg(ddev, "HDMI-0 Reset\n");
 248 }
 249
 250 static void ls7a2000_hdmi1_encoder_reset(struct drm_encoder *encoder)
 251 {
 252         struct drm_device *ddev = encoder->dev;
 253         struct lsdc_device *ldev = to_lsdc(ddev);
 254         u32 val;
 255
 256         val = PHY_CLOCK_POL | PHY_CLOCK_EN | PHY_DATA_EN;
 257         lsdc_wreg32(ldev, LSDC_CRTC1_DVO_CONF_REG, val);
 258
 259         /* using software gpio emulated i2c */
 260         val = lsdc_rreg32(ldev, LSDC_HDMI1_INTF_CTRL_REG);
 261         val &= ~HW_I2C_EN;
 262         lsdc_wreg32(ldev, LSDC_HDMI1_INTF_CTRL_REG, val);
 263
 264         /*  help the hdmi phy to get out of reset state */
 265         lsdc_wreg32(ldev, LSDC_HDMI1_PHY_CTRL_REG, HDMI_PHY_RESET_N);
 266
 267         mdelay(20);
 268
 269         drm_dbg(ddev, "HDMI-1 Reset\n");
 270 }
 271
 272 static const struct drm_encoder_funcs ls7a2000_encoder_funcs[2] = {
 273         {
 274                 .reset = ls7a2000_hdmi0_encoder_reset,
 275                 .destroy = drm_encoder_cleanup,
 276         },
 277         {
 278                 .reset = ls7a2000_hdmi1_encoder_reset,
 279                 .destroy = drm_encoder_cleanup,
 280         },
 281 };
 282
 283 static int ls7a2000_hdmi_set_avi_infoframe(struct drm_encoder *encoder,
 284                                            struct drm_display_mode *mode)
 285 {
 286         struct lsdc_output *output = encoder_to_lsdc_output(encoder);
 287         struct lsdc_display_pipe *dispipe = output_to_display_pipe(output);
 288         unsigned int index = dispipe->index;
 289         struct drm_device *ddev = encoder->dev;
 290         struct lsdc_device *ldev = to_lsdc(ddev);
 291         struct hdmi_avi_infoframe infoframe;
 292         u8 buffer[HDMI_INFOFRAME_SIZE(AVI)];
 293         unsigned char *ptr = &buffer[HDMI_INFOFRAME_HEADER_SIZE];
 294         unsigned int content0, content1, content2, content3;
 295         int err;
 296
 297         err = drm_hdmi_avi_infoframe_from_display_mode(&infoframe,
 298                                                        &output->connector,
 299                                                        mode);
 300         if (err < 0) {
 301                 drm_err(ddev, "failed to setup AVI infoframe: %d\n", err);
 302                 return err;
 303         }
 304
 305         /* Fixed infoframe configuration not linked to the mode */
 306         infoframe.colorspace = HDMI_COLORSPACE_RGB;
 307         infoframe.quantization_range = HDMI_QUANTIZATION_RANGE_DEFAULT;
 308         infoframe.colorimetry = HDMI_COLORIMETRY_NONE;
 309
 310         err = hdmi_avi_infoframe_pack(&infoframe, buffer, sizeof(buffer));
 311         if (err < 0) {
 312                 drm_err(ddev, "failed to pack AVI infoframe: %d\n", err);
 313                         return err;
 314         }
 315
 316         content0 = *(unsigned int *)ptr;
 317         content1 = *(ptr + 4);
 318         content2 = *(unsigned int *)(ptr + 5);
 319         content3 = *(unsigned int *)(ptr + 9);
 320
 321         lsdc_pipe_wreg32(ldev, LSDC_HDMI0_AVI_CONTENT0, index, content0);
 322         lsdc_pipe_wreg32(ldev, LSDC_HDMI0_AVI_CONTENT1, index, content1);
 323         lsdc_pipe_wreg32(ldev, LSDC_HDMI0_AVI_CONTENT2, index, content2);
 324         lsdc_pipe_wreg32(ldev, LSDC_HDMI0_AVI_CONTENT3, index, content3);
 325
 326         lsdc_pipe_wreg32(ldev, LSDC_HDMI0_AVI_INFO_CRTL_REG, index,
 327                          AVI_PKT_ENABLE | AVI_PKT_UPDATE);
 328
 329         drm_dbg(ddev, "Update HDMI-%u avi infoframe\n", index);
 330
 331         return 0;
 332 }
 333
 334 static void ls7a2000_hdmi_atomic_disable(struct drm_encoder *encoder,
 335                                          struct drm_atomic_state *state)
 336 {
 337         struct lsdc_output *output = encoder_to_lsdc_output(encoder);
 338         struct lsdc_display_pipe *dispipe = output_to_display_pipe(output);
 339         unsigned int index = dispipe->index;
 340         struct drm_device *ddev = encoder->dev;
 341         struct lsdc_device *ldev = to_lsdc(ddev);
 342         u32 val;
 343
 344         /* Disable the hdmi phy */
 345         val = lsdc_pipe_rreg32(ldev, LSDC_HDMI0_PHY_CTRL_REG, index);
 346         val &= ~HDMI_PHY_EN;
 347         lsdc_pipe_wreg32(ldev, LSDC_HDMI0_PHY_CTRL_REG, index, val);
 348
 349         /* Disable the hdmi interface */
 350         val = lsdc_pipe_rreg32(ldev, LSDC_HDMI0_INTF_CTRL_REG, index);
 351         val &= ~HDMI_INTERFACE_EN;
 352         lsdc_pipe_wreg32(ldev, LSDC_HDMI0_INTF_CTRL_REG, index, val);
 353
 354         drm_dbg(ddev, "HDMI-%u disabled\n", index);
 355 }
 356
 357 static void ls7a2000_hdmi_atomic_enable(struct drm_encoder *encoder,
 358                                         struct drm_atomic_state *state)
 359 {
 360         struct drm_device *ddev = encoder->dev;
 361         struct lsdc_device *ldev = to_lsdc(ddev);
 362         struct lsdc_output *output = encoder_to_lsdc_output(encoder);
 363         struct lsdc_display_pipe *dispipe = output_to_display_pipe(output);
 364         unsigned int index = dispipe->index;
 365         u32 val;
 366
 367         /* datasheet say it should larger than 48 */
 368         val = 64 << HDMI_H_ZONE_IDLE_SHIFT | 64 << HDMI_V_ZONE_IDLE_SHIFT;
 369
 370         lsdc_pipe_wreg32(ldev, LSDC_HDMI0_ZONE_REG, index, val);
 371
 372         val = HDMI_PHY_TERM_STATUS |
 373               HDMI_PHY_TERM_DET_EN |
 374               HDMI_PHY_TERM_H_EN |
 375               HDMI_PHY_TERM_L_EN |
 376               HDMI_PHY_RESET_N |
 377               HDMI_PHY_EN;
 378
 379         lsdc_pipe_wreg32(ldev, LSDC_HDMI0_PHY_CTRL_REG, index, val);
 380
 381         udelay(2);
 382
 383         val = HDMI_CTL_PERIOD_MODE |
 384               HDMI_AUDIO_EN |
 385               HDMI_PACKET_EN |
 386               HDMI_INTERFACE_EN |
 387               (8 << HDMI_VIDEO_PREAMBLE_SHIFT);
 388
 389         lsdc_pipe_wreg32(ldev, LSDC_HDMI0_INTF_CTRL_REG, index, val);
 390
 391         drm_dbg(ddev, "HDMI-%u enabled\n", index);
 392 }
 393
 394 /*
 395  *  Fout = M * Fin
 396  *
 397  *  M = (4 * LF) / (IDF * ODF)
 398  *
 399  *  IDF: Input Division Factor
 400  *  ODF: Output Division Factor
 401  *   LF: Loop Factor
 402  *    M: Required Mult
 403  *
 404  *  +--------------------------------------------------------+
 405  *  |     Fin (kHZ)     | M  | IDF | LF | ODF |   Fout(Mhz)  |
 406  *  |-------------------+----+-----+----+-----+--------------|
 407  *  |  170000 ~ 340000  | 10 | 16  | 40 |  1  | 1700 ~ 3400  |
 408  *  |   85000 ~ 170000  | 10 |  8  | 40 |  2  |  850 ~ 1700  |
 409  *  |   42500 ~  85000  | 10 |  4  | 40 |  4  |  425 ~ 850   |
 410  *  |   21250 ~  42500  | 10 |  2  | 40 |  8  | 212.5 ~ 425  |
 411  *  |   20000 ~  21250  | 10 |  1  | 40 | 16  |  200 ~ 212.5 |
 412  *  +--------------------------------------------------------+
 413  */
 414 static void ls7a2000_hdmi_phy_pll_config(struct lsdc_device *ldev,
 415                                          int fin,
 416                                          unsigned int index)
 417 {
 418         struct drm_device *ddev = &ldev->base;
 419         int count = 0;
 420         u32 val;
 421
 422         /* Firstly, disable phy pll */
 423         lsdc_pipe_wreg32(ldev, LSDC_HDMI0_PHY_PLL_REG, index, 0x0);
 424
 425         /*
 426          * Most of time, loongson HDMI require M = 10
 427          * for example, 10 = (4 * 40) / (8 * 2)
 428          * here, write "1" to the ODF will get "2"
 429          */
 430
 431         if (fin >= 170000)
 432                 val = (16 << HDMI_PLL_IDF_SHIFT) |
 433                       (40 << HDMI_PLL_LF_SHIFT) |
 434                       (0 << HDMI_PLL_ODF_SHIFT);
 435         else if (fin >= 85000)
 436                 val = (8 << HDMI_PLL_IDF_SHIFT) |
 437                       (40 << HDMI_PLL_LF_SHIFT) |
 438                       (1 << HDMI_PLL_ODF_SHIFT);
 439         else if (fin >= 42500)
 440                 val = (4 << HDMI_PLL_IDF_SHIFT) |
 441                       (40 << HDMI_PLL_LF_SHIFT) |
 442                       (2 << HDMI_PLL_ODF_SHIFT);
 443         else if  (fin >= 21250)
 444                 val = (2 << HDMI_PLL_IDF_SHIFT) |
 445                       (40 << HDMI_PLL_LF_SHIFT) |
 446                       (3 << HDMI_PLL_ODF_SHIFT);
 447         else
 448                 val = (1 << HDMI_PLL_IDF_SHIFT) |
 449                       (40 << HDMI_PLL_LF_SHIFT) |
 450                       (4 << HDMI_PLL_ODF_SHIFT);
 451
 452         lsdc_pipe_wreg32(ldev, LSDC_HDMI0_PHY_PLL_REG, index, val);
 453
 454         val |= HDMI_PLL_ENABLE;
 455
 456         lsdc_pipe_wreg32(ldev, LSDC_HDMI0_PHY_PLL_REG, index, val);
 457
 458         udelay(2);
 459
 460         drm_dbg(ddev, "Fin of HDMI-%u: %d kHz\n", index, fin);
 461
 462         /* Wait hdmi phy pll lock */
 463         do {
 464                 val = lsdc_pipe_rreg32(ldev, LSDC_HDMI0_PHY_PLL_REG, index);
 465
 466                 if (val & HDMI_PLL_LOCKED) {
 467                         drm_dbg(ddev, "Setting HDMI-%u PLL take %d cycles\n",
 468                                 index, count);
 469                         break;
 470                 }
 471                 ++count;
 472         } while (count < 1000);
 473
 474         lsdc_pipe_wreg32(ldev, LSDC_HDMI0_PHY_CAL_REG, index, 0x0f000ff0);
 475
 476         if (count >= 1000)
 477                 drm_err(ddev, "Setting HDMI-%u PLL failed\n", index);
 478 }
 479
 480 static void ls7a2000_hdmi_atomic_mode_set(struct drm_encoder *encoder,
 481                                           struct drm_crtc_state *crtc_state,
 482                                           struct drm_connector_state *conn_state)
 483 {
 484         struct lsdc_output *output = encoder_to_lsdc_output(encoder);
 485         struct lsdc_display_pipe *dispipe = output_to_display_pipe(output);
 486         unsigned int index = dispipe->index;
 487         struct drm_device *ddev = encoder->dev;
 488         struct lsdc_device *ldev = to_lsdc(ddev);
 489         struct drm_display_mode *mode = &crtc_state->mode;
 490
 491         ls7a2000_hdmi_phy_pll_config(ldev, mode->clock, index);
 492
 493         ls7a2000_hdmi_set_avi_infoframe(encoder, mode);
 494
 495         drm_dbg(ddev, "%s modeset finished\n", encoder->name);
 496 }
 497
 498 static const struct drm_encoder_helper_funcs ls7a2000_encoder_helper_funcs = {
 499         .atomic_disable = ls7a2000_hdmi_atomic_disable,
 500         .atomic_enable = ls7a2000_hdmi_atomic_enable,
 501         .atomic_mode_set = ls7a2000_hdmi_atomic_mode_set,
 502 };
 503
 504 /*
 505  * For LS7A2000:
 506  *
 507  * 1) Most of board export one vga + hdmi output interface.
 508  * 2) Yet, Some boards export double hdmi output interface.
 509  * 3) Still have boards export three output(2 hdmi + 1 vga).
 510  *
 511  * So let's hook hdmi helper funcs to all display pipe, don't miss.
 512  * writing hdmi register do no harms.
 513  */
 514 int ls7a2000_output_init(struct drm_device *ddev,
 515                          struct lsdc_display_pipe *dispipe,
 516                          struct i2c_adapter *ddc,
 517                          unsigned int pipe)
 518 {
 519         struct lsdc_output *output = &dispipe->output;
 520         struct drm_encoder *encoder = &output->encoder;
 521         struct drm_connector *connector = &output->connector;
 522         int ret;
 523
 524         ret = drm_encoder_init(ddev, encoder, &ls7a2000_encoder_funcs[pipe],
 525                                DRM_MODE_ENCODER_TMDS, "encoder-%u", pipe);
 526         if (ret)
 527                 return ret;
 528
 529         encoder->possible_crtcs = BIT(pipe);
 530
 531         drm_encoder_helper_add(encoder, &ls7a2000_encoder_helper_funcs);
 532
 533         ret = drm_connector_init_with_ddc(ddev, connector,
 534                                           &ls7a2000_hdmi_connector_funcs[pipe],
 535                                           DRM_MODE_CONNECTOR_HDMIA, ddc);
 536         if (ret)
 537                 return ret;
 538
 539         drm_info(ddev, "display pipe-%u has HDMI %s\n", pipe, pipe ? "" : "and/or VGA");
 540
 541         drm_connector_helper_add(connector, &ls7a2000_connector_helpers);
 542
 543         drm_connector_attach_encoder(connector, encoder);
 544
 545         connector->polled = DRM_CONNECTOR_POLL_CONNECT |
 546                             DRM_CONNECTOR_POLL_DISCONNECT;
 547
 548         connector->interlace_allowed = 0;
 549         connector->doublescan_allowed = 0;
 550
 551         return 0;
 552 }