drivers/gpu/drm/radeon/radeon_connectors.c

   1 /*
   2  * Copyright 2007-8 Advanced Micro Devices, Inc.
   3  * Copyright 2008 Red Hat Inc.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be included in
  13  * all copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
  19  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  20  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  21  * OTHER DEALINGS IN THE SOFTWARE.
  22  *
  23  * Authors: Dave Airlie
  24  *          Alex Deucher
  25  */
  26 #include <drm/drmP.h>
  27 #include <drm/drm_edid.h>
  28 #include <drm/drm_crtc_helper.h>
  29 #include <drm/drm_fb_helper.h>
  30 #include <drm/radeon_drm.h>
  31 #include "radeon.h"
  32 #include "atom.h"
  33
  34 #include <linux/pm_runtime.h>
  35
  36 void radeon_connector_hotplug(struct drm_connector *connector)
  37 {
  38         struct drm_device *dev = connector->dev;
  39         struct radeon_device *rdev = dev->dev_private;
  40         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  41
  42         /* bail if the connector does not have hpd pin, e.g.,
  43          * VGA, TV, etc.
  44          */
  45         if (radeon_connector->hpd.hpd == RADEON_HPD_NONE)
  46                 return;
  47
  48         radeon_hpd_set_polarity(rdev, radeon_connector->hpd.hpd);
  49
  50         /* if the connector is already off, don't turn it back on */
  51         if (connector->dpms != DRM_MODE_DPMS_ON)
  52                 return;
  53
  54         /* just deal with DP (not eDP) here. */
  55         if (connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort) {
  56                 struct radeon_connector_atom_dig *dig_connector =
  57                         radeon_connector->con_priv;
  58
  59                 /* if existing sink type was not DP no need to retrain */
  60                 if (dig_connector->dp_sink_type != CONNECTOR_OBJECT_ID_DISPLAYPORT)
  61                         return;
  62
  63                 /* first get sink type as it may be reset after (un)plug */
  64                 dig_connector->dp_sink_type = radeon_dp_getsinktype(radeon_connector);
  65                 /* don't do anything if sink is not display port, i.e.,
  66                  * passive dp->(dvi|hdmi) adaptor
  67                  */
  68                 if (dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) {
  69                         int saved_dpms = connector->dpms;
  70                         /* Only turn off the display if it's physically disconnected */
  71                         if (!radeon_hpd_sense(rdev, radeon_connector->hpd.hpd)) {
  72                                 drm_helper_connector_dpms(connector, DRM_MODE_DPMS_OFF);
  73                         } else if (radeon_dp_needs_link_train(radeon_connector)) {
  74                                 /* set it to OFF so that drm_helper_connector_dpms()
  75                                  * won't return immediately since the current state
  76                                  * is ON at this point.
  77                                  */
  78                                 connector->dpms = DRM_MODE_DPMS_OFF;
  79                                 drm_helper_connector_dpms(connector, DRM_MODE_DPMS_ON);
  80                         }
  81                         connector->dpms = saved_dpms;
  82                 }
  83         }
  84 }
  85
  86 static void radeon_property_change_mode(struct drm_encoder *encoder)
  87 {
  88         struct drm_crtc *crtc = encoder->crtc;
  89
  90         if (crtc && crtc->enabled) {
  91                 drm_crtc_helper_set_mode(crtc, &crtc->mode,
  92                                          crtc->x, crtc->y, crtc->primary->fb);
  93         }
  94 }
  95
  96 int radeon_get_monitor_bpc(struct drm_connector *connector)
  97 {
  98         struct drm_device *dev = connector->dev;
  99         struct radeon_device *rdev = dev->dev_private;
 100         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 101         struct radeon_connector_atom_dig *dig_connector;
 102         int bpc = 8;
 103
 104         switch (connector->connector_type) {
 105         case DRM_MODE_CONNECTOR_DVII:
 106         case DRM_MODE_CONNECTOR_HDMIB:
 107                 if (radeon_connector->use_digital) {
 108                         if (drm_detect_hdmi_monitor(radeon_connector->edid)) {
 109                                 if (connector->display_info.bpc)
 110                                         bpc = connector->display_info.bpc;
 111                         }
 112                 }
 113                 break;
 114         case DRM_MODE_CONNECTOR_DVID:
 115         case DRM_MODE_CONNECTOR_HDMIA:
 116                 if (drm_detect_hdmi_monitor(radeon_connector->edid)) {
 117                         if (connector->display_info.bpc)
 118                                 bpc = connector->display_info.bpc;
 119                 }
 120                 break;
 121         case DRM_MODE_CONNECTOR_DisplayPort:
 122                 dig_connector = radeon_connector->con_priv;
 123                 if ((dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) ||
 124                     (dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_eDP) ||
 125                     drm_detect_hdmi_monitor(radeon_connector->edid)) {
 126                         if (connector->display_info.bpc)
 127                                 bpc = connector->display_info.bpc;
 128                 }
 129                 break;
 130         case DRM_MODE_CONNECTOR_eDP:
 131         case DRM_MODE_CONNECTOR_LVDS:
 132                 if (connector->display_info.bpc)
 133                         bpc = connector->display_info.bpc;
 134                 else if (ASIC_IS_DCE41(rdev) || ASIC_IS_DCE5(rdev)) {
 135                         struct drm_connector_helper_funcs *connector_funcs =
 136                                 connector->helper_private;
 137                         struct drm_encoder *encoder = connector_funcs->best_encoder(connector);
 138                         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
 139                         struct radeon_encoder_atom_dig *dig = radeon_encoder->enc_priv;
 140
 141                         if (dig->lcd_misc & ATOM_PANEL_MISC_V13_6BIT_PER_COLOR)
 142                                 bpc = 6;
 143                         else if (dig->lcd_misc & ATOM_PANEL_MISC_V13_8BIT_PER_COLOR)
 144                                 bpc = 8;
 145                 }
 146                 break;
 147         }
 148         return bpc;
 149 }
 150
 151 static void
 152 radeon_connector_update_scratch_regs(struct drm_connector *connector, enum drm_connector_status status)
 153 {
 154         struct drm_device *dev = connector->dev;
 155         struct radeon_device *rdev = dev->dev_private;
 156         struct drm_encoder *best_encoder = NULL;
 157         struct drm_encoder *encoder = NULL;
 158         struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
 159         struct drm_mode_object *obj;
 160         bool connected;
 161         int i;
 162
 163         best_encoder = connector_funcs->best_encoder(connector);
 164
 165         for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
 166                 if (connector->encoder_ids[i] == 0)
 167                         break;
 168
 169                 obj = drm_mode_object_find(connector->dev,
 170                                            connector->encoder_ids[i],
 171                                            DRM_MODE_OBJECT_ENCODER);
 172                 if (!obj)
 173                         continue;
 174
 175                 encoder = obj_to_encoder(obj);
 176
 177                 if ((encoder == best_encoder) && (status == connector_status_connected))
 178                         connected = true;
 179                 else
 180                         connected = false;
 181
 182                 if (rdev->is_atom_bios)
 183                         radeon_atombios_connected_scratch_regs(connector, encoder, connected);
 184                 else
 185                         radeon_combios_connected_scratch_regs(connector, encoder, connected);
 186
 187         }
 188 }
 189
 190 static struct drm_encoder *radeon_find_encoder(struct drm_connector *connector, int encoder_type)
 191 {
 192         struct drm_mode_object *obj;
 193         struct drm_encoder *encoder;
 194         int i;
 195
 196         for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
 197                 if (connector->encoder_ids[i] == 0)
 198                         break;
 199
 200                 obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER);
 201                 if (!obj)
 202                         continue;
 203
 204                 encoder = obj_to_encoder(obj);
 205                 if (encoder->encoder_type == encoder_type)
 206                         return encoder;
 207         }
 208         return NULL;
 209 }
 210
 211 static struct drm_encoder *radeon_best_single_encoder(struct drm_connector *connector)
 212 {
 213         int enc_id = connector->encoder_ids[0];
 214         struct drm_mode_object *obj;
 215         struct drm_encoder *encoder;
 216
 217         /* pick the encoder ids */
 218         if (enc_id) {
 219                 obj = drm_mode_object_find(connector->dev, enc_id, DRM_MODE_OBJECT_ENCODER);
 220                 if (!obj)
 221                         return NULL;
 222                 encoder = obj_to_encoder(obj);
 223                 return encoder;
 224         }
 225         return NULL;
 226 }
 227
 228 /*
 229  * radeon_connector_analog_encoder_conflict_solve
 230  * - search for other connectors sharing this encoder
 231  *   if priority is true, then set them disconnected if this is connected
 232  *   if priority is false, set us disconnected if they are connected
 233  */
 234 static enum drm_connector_status
 235 radeon_connector_analog_encoder_conflict_solve(struct drm_connector *connector,
 236                                                struct drm_encoder *encoder,
 237                                                enum drm_connector_status current_status,
 238                                                bool priority)
 239 {
 240         struct drm_device *dev = connector->dev;
 241         struct drm_connector *conflict;
 242         struct radeon_connector *radeon_conflict;
 243         int i;
 244
 245         list_for_each_entry(conflict, &dev->mode_config.connector_list, head) {
 246                 if (conflict == connector)
 247                         continue;
 248
 249                 radeon_conflict = to_radeon_connector(conflict);
 250                 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
 251                         if (conflict->encoder_ids[i] == 0)
 252                                 break;
 253
 254                         /* if the IDs match */
 255                         if (conflict->encoder_ids[i] == encoder->base.id) {
 256                                 if (conflict->status != connector_status_connected)
 257                                         continue;
 258
 259                                 if (radeon_conflict->use_digital)
 260                                         continue;
 261
 262                                 if (priority == true) {
 263                                         DRM_DEBUG_KMS("1: conflicting encoders switching off %s\n", drm_get_connector_name(conflict));
 264                                         DRM_DEBUG_KMS("in favor of %s\n", drm_get_connector_name(connector));
 265                                         conflict->status = connector_status_disconnected;
 266                                         radeon_connector_update_scratch_regs(conflict, connector_status_disconnected);
 267                                 } else {
 268                                         DRM_DEBUG_KMS("2: conflicting encoders switching off %s\n", drm_get_connector_name(connector));
 269                                         DRM_DEBUG_KMS("in favor of %s\n", drm_get_connector_name(conflict));
 270                                         current_status = connector_status_disconnected;
 271                                 }
 272                                 break;
 273                         }
 274                 }
 275         }
 276         return current_status;
 277
 278 }
 279
 280 static struct drm_display_mode *radeon_fp_native_mode(struct drm_encoder *encoder)
 281 {
 282         struct drm_device *dev = encoder->dev;
 283         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
 284         struct drm_display_mode *mode = NULL;
 285         struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
 286
 287         if (native_mode->hdisplay != 0 &&
 288             native_mode->vdisplay != 0 &&
 289             native_mode->clock != 0) {
 290                 mode = drm_mode_duplicate(dev, native_mode);
 291                 mode->type = DRM_MODE_TYPE_PREFERRED | DRM_MODE_TYPE_DRIVER;
 292                 drm_mode_set_name(mode);
 293
 294                 DRM_DEBUG_KMS("Adding native panel mode %s\n", mode->name);
 295         } else if (native_mode->hdisplay != 0 &&
 296                    native_mode->vdisplay != 0) {
 297                 /* mac laptops without an edid */
 298                 /* Note that this is not necessarily the exact panel mode,
 299                  * but an approximation based on the cvt formula.  For these
 300                  * systems we should ideally read the mode info out of the
 301                  * registers or add a mode table, but this works and is much
 302                  * simpler.
 303                  */
 304                 mode = drm_cvt_mode(dev, native_mode->hdisplay, native_mode->vdisplay, 60, true, false, false);
 305                 mode->type = DRM_MODE_TYPE_PREFERRED | DRM_MODE_TYPE_DRIVER;
 306                 DRM_DEBUG_KMS("Adding cvt approximation of native panel mode %s\n", mode->name);
 307         }
 308         return mode;
 309 }
 310
 311 static void radeon_add_common_modes(struct drm_encoder *encoder, struct drm_connector *connector)
 312 {
 313         struct drm_device *dev = encoder->dev;
 314         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
 315         struct drm_display_mode *mode = NULL;
 316         struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
 317         int i;
 318         struct mode_size {
 319                 int w;
 320                 int h;
 321         } common_modes[17] = {
 322                 { 640,  480},
 323                 { 720,  480},
 324                 { 800,  600},
 325                 { 848,  480},
 326                 {1024,  768},
 327                 {1152,  768},
 328                 {1280,  720},
 329                 {1280,  800},
 330                 {1280,  854},
 331                 {1280,  960},
 332                 {1280, 1024},
 333                 {1440,  900},
 334                 {1400, 1050},
 335                 {1680, 1050},
 336                 {1600, 1200},
 337                 {1920, 1080},
 338                 {1920, 1200}
 339         };
 340
 341         for (i = 0; i < 17; i++) {
 342                 if (radeon_encoder->devices & (ATOM_DEVICE_TV_SUPPORT)) {
 343                         if (common_modes[i].w > 1024 ||
 344                             common_modes[i].h > 768)
 345                                 continue;
 346                 }
 347                 if (radeon_encoder->devices & (ATOM_DEVICE_LCD_SUPPORT)) {
 348                         if (common_modes[i].w > native_mode->hdisplay ||
 349                             common_modes[i].h > native_mode->vdisplay ||
 350                             (common_modes[i].w == native_mode->hdisplay &&
 351                              common_modes[i].h == native_mode->vdisplay))
 352                                 continue;
 353                 }
 354                 if (common_modes[i].w < 320 || common_modes[i].h < 200)
 355                         continue;
 356
 357                 mode = drm_cvt_mode(dev, common_modes[i].w, common_modes[i].h, 60, false, false, false);
 358                 drm_mode_probed_add(connector, mode);
 359         }
 360 }
 361
 362 static int radeon_connector_set_property(struct drm_connector *connector, struct drm_property *property,
 363                                   uint64_t val)
 364 {
 365         struct drm_device *dev = connector->dev;
 366         struct radeon_device *rdev = dev->dev_private;
 367         struct drm_encoder *encoder;
 368         struct radeon_encoder *radeon_encoder;
 369
 370         if (property == rdev->mode_info.coherent_mode_property) {
 371                 struct radeon_encoder_atom_dig *dig;
 372                 bool new_coherent_mode;
 373
 374                 /* need to find digital encoder on connector */
 375                 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
 376                 if (!encoder)
 377                         return 0;
 378
 379                 radeon_encoder = to_radeon_encoder(encoder);
 380
 381                 if (!radeon_encoder->enc_priv)
 382                         return 0;
 383
 384                 dig = radeon_encoder->enc_priv;
 385                 new_coherent_mode = val ? true : false;
 386                 if (dig->coherent_mode != new_coherent_mode) {
 387                         dig->coherent_mode = new_coherent_mode;
 388                         radeon_property_change_mode(&radeon_encoder->base);
 389                 }
 390         }
 391
 392         if (property == rdev->mode_info.audio_property) {
 393                 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 394                 /* need to find digital encoder on connector */
 395                 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
 396                 if (!encoder)
 397                         return 0;
 398
 399                 radeon_encoder = to_radeon_encoder(encoder);
 400
 401                 if (radeon_connector->audio != val) {
 402                         radeon_connector->audio = val;
 403                         radeon_property_change_mode(&radeon_encoder->base);
 404                 }
 405         }
 406
 407         if (property == rdev->mode_info.dither_property) {
 408                 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 409                 /* need to find digital encoder on connector */
 410                 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
 411                 if (!encoder)
 412                         return 0;
 413
 414                 radeon_encoder = to_radeon_encoder(encoder);
 415
 416                 if (radeon_connector->dither != val) {
 417                         radeon_connector->dither = val;
 418                         radeon_property_change_mode(&radeon_encoder->base);
 419                 }
 420         }
 421
 422         if (property == rdev->mode_info.underscan_property) {
 423                 /* need to find digital encoder on connector */
 424                 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
 425                 if (!encoder)
 426                         return 0;
 427
 428                 radeon_encoder = to_radeon_encoder(encoder);
 429
 430                 if (radeon_encoder->underscan_type != val) {
 431                         radeon_encoder->underscan_type = val;
 432                         radeon_property_change_mode(&radeon_encoder->base);
 433                 }
 434         }
 435
 436         if (property == rdev->mode_info.underscan_hborder_property) {
 437                 /* need to find digital encoder on connector */
 438                 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
 439                 if (!encoder)
 440                         return 0;
 441
 442                 radeon_encoder = to_radeon_encoder(encoder);
 443
 444                 if (radeon_encoder->underscan_hborder != val) {
 445                         radeon_encoder->underscan_hborder = val;
 446                         radeon_property_change_mode(&radeon_encoder->base);
 447                 }
 448         }
 449
 450         if (property == rdev->mode_info.underscan_vborder_property) {
 451                 /* need to find digital encoder on connector */
 452                 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
 453                 if (!encoder)
 454                         return 0;
 455
 456                 radeon_encoder = to_radeon_encoder(encoder);
 457
 458                 if (radeon_encoder->underscan_vborder != val) {
 459                         radeon_encoder->underscan_vborder = val;
 460                         radeon_property_change_mode(&radeon_encoder->base);
 461                 }
 462         }
 463
 464         if (property == rdev->mode_info.tv_std_property) {
 465                 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TVDAC);
 466                 if (!encoder) {
 467                         encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_DAC);
 468                 }
 469
 470                 if (!encoder)
 471                         return 0;
 472
 473                 radeon_encoder = to_radeon_encoder(encoder);
 474                 if (!radeon_encoder->enc_priv)
 475                         return 0;
 476                 if (ASIC_IS_AVIVO(rdev) || radeon_r4xx_atom) {
 477                         struct radeon_encoder_atom_dac *dac_int;
 478                         dac_int = radeon_encoder->enc_priv;
 479                         dac_int->tv_std = val;
 480                 } else {
 481                         struct radeon_encoder_tv_dac *dac_int;
 482                         dac_int = radeon_encoder->enc_priv;
 483                         dac_int->tv_std = val;
 484                 }
 485                 radeon_property_change_mode(&radeon_encoder->base);
 486         }
 487
 488         if (property == rdev->mode_info.load_detect_property) {
 489                 struct radeon_connector *radeon_connector =
 490                         to_radeon_connector(connector);
 491
 492                 if (val == 0)
 493                         radeon_connector->dac_load_detect = false;
 494                 else
 495                         radeon_connector->dac_load_detect = true;
 496         }
 497
 498         if (property == rdev->mode_info.tmds_pll_property) {
 499                 struct radeon_encoder_int_tmds *tmds = NULL;
 500                 bool ret = false;
 501                 /* need to find digital encoder on connector */
 502                 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
 503                 if (!encoder)
 504                         return 0;
 505
 506                 radeon_encoder = to_radeon_encoder(encoder);
 507
 508                 tmds = radeon_encoder->enc_priv;
 509                 if (!tmds)
 510                         return 0;
 511
 512                 if (val == 0) {
 513                         if (rdev->is_atom_bios)
 514                                 ret = radeon_atombios_get_tmds_info(radeon_encoder, tmds);
 515                         else
 516                                 ret = radeon_legacy_get_tmds_info_from_combios(radeon_encoder, tmds);
 517                 }
 518                 if (val == 1 || ret == false) {
 519                         radeon_legacy_get_tmds_info_from_table(radeon_encoder, tmds);
 520                 }
 521                 radeon_property_change_mode(&radeon_encoder->base);
 522         }
 523
 524         return 0;
 525 }
 526
 527 static void radeon_fixup_lvds_native_mode(struct drm_encoder *encoder,
 528                                           struct drm_connector *connector)
 529 {
 530         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
 531         struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
 532         struct drm_display_mode *t, *mode;
 533
 534         /* If the EDID preferred mode doesn't match the native mode, use it */
 535         list_for_each_entry_safe(mode, t, &connector->probed_modes, head) {
 536                 if (mode->type & DRM_MODE_TYPE_PREFERRED) {
 537                         if (mode->hdisplay != native_mode->hdisplay ||
 538                             mode->vdisplay != native_mode->vdisplay)
 539                                 memcpy(native_mode, mode, sizeof(*mode));
 540                 }
 541         }
 542
 543         /* Try to get native mode details from EDID if necessary */
 544         if (!native_mode->clock) {
 545                 list_for_each_entry_safe(mode, t, &connector->probed_modes, head) {
 546                         if (mode->hdisplay == native_mode->hdisplay &&
 547                             mode->vdisplay == native_mode->vdisplay) {
 548                                 *native_mode = *mode;
 549                                 drm_mode_set_crtcinfo(native_mode, CRTC_INTERLACE_HALVE_V);
 550                                 DRM_DEBUG_KMS("Determined LVDS native mode details from EDID\n");
 551                                 break;
 552                         }
 553                 }
 554         }
 555
 556         if (!native_mode->clock) {
 557                 DRM_DEBUG_KMS("No LVDS native mode details, disabling RMX\n");
 558                 radeon_encoder->rmx_type = RMX_OFF;
 559         }
 560 }
 561
 562 static int radeon_lvds_get_modes(struct drm_connector *connector)
 563 {
 564         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 565         struct drm_encoder *encoder;
 566         int ret = 0;
 567         struct drm_display_mode *mode;
 568
 569         if (radeon_connector->ddc_bus) {
 570                 ret = radeon_ddc_get_modes(radeon_connector);
 571                 if (ret > 0) {
 572                         encoder = radeon_best_single_encoder(connector);
 573                         if (encoder) {
 574                                 radeon_fixup_lvds_native_mode(encoder, connector);
 575                                 /* add scaled modes */
 576                                 radeon_add_common_modes(encoder, connector);
 577                         }
 578                         return ret;
 579                 }
 580         }
 581
 582         encoder = radeon_best_single_encoder(connector);
 583         if (!encoder)
 584                 return 0;
 585
 586         /* we have no EDID modes */
 587         mode = radeon_fp_native_mode(encoder);
 588         if (mode) {
 589                 ret = 1;
 590                 drm_mode_probed_add(connector, mode);
 591                 /* add the width/height from vbios tables if available */
 592                 connector->display_info.width_mm = mode->width_mm;
 593                 connector->display_info.height_mm = mode->height_mm;
 594                 /* add scaled modes */
 595                 radeon_add_common_modes(encoder, connector);
 596         }
 597
 598         return ret;
 599 }
 600
 601 static int radeon_lvds_mode_valid(struct drm_connector *connector,
 602                                   struct drm_display_mode *mode)
 603 {
 604         struct drm_encoder *encoder = radeon_best_single_encoder(connector);
 605
 606         if ((mode->hdisplay < 320) || (mode->vdisplay < 240))
 607                 return MODE_PANEL;
 608
 609         if (encoder) {
 610                 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
 611                 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
 612
 613                 /* AVIVO hardware supports downscaling modes larger than the panel
 614                  * to the panel size, but I'm not sure this is desirable.
 615                  */
 616                 if ((mode->hdisplay > native_mode->hdisplay) ||
 617                     (mode->vdisplay > native_mode->vdisplay))
 618                         return MODE_PANEL;
 619
 620                 /* if scaling is disabled, block non-native modes */
 621                 if (radeon_encoder->rmx_type == RMX_OFF) {
 622                         if ((mode->hdisplay != native_mode->hdisplay) ||
 623                             (mode->vdisplay != native_mode->vdisplay))
 624                                 return MODE_PANEL;
 625                 }
 626         }
 627
 628         return MODE_OK;
 629 }
 630
 631 static enum drm_connector_status
 632 radeon_lvds_detect(struct drm_connector *connector, bool force)
 633 {
 634         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 635         struct drm_encoder *encoder = radeon_best_single_encoder(connector);
 636         enum drm_connector_status ret = connector_status_disconnected;
 637         int r;
 638
 639         r = pm_runtime_get_sync(connector->dev->dev);
 640         if (r < 0)
 641                 return connector_status_disconnected;
 642
 643         if (encoder) {
 644                 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
 645                 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
 646
 647                 /* check if panel is valid */
 648                 if (native_mode->hdisplay >= 320 && native_mode->vdisplay >= 240)
 649                         ret = connector_status_connected;
 650
 651         }
 652
 653         /* check for edid as well */
 654         if (radeon_connector->edid)
 655                 ret = connector_status_connected;
 656         else {
 657                 if (radeon_connector->ddc_bus) {
 658                         radeon_connector->edid = drm_get_edid(&radeon_connector->base,
 659                                                               &radeon_connector->ddc_bus->adapter);
 660                         if (radeon_connector->edid)
 661                                 ret = connector_status_connected;
 662                 }
 663         }
 664         /* check acpi lid status ??? */
 665
 666         radeon_connector_update_scratch_regs(connector, ret);
 667         pm_runtime_mark_last_busy(connector->dev->dev);
 668         pm_runtime_put_autosuspend(connector->dev->dev);
 669         return ret;
 670 }
 671
 672 static void radeon_connector_destroy(struct drm_connector *connector)
 673 {
 674         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 675
 676         if (radeon_connector->edid)
 677                 kfree(radeon_connector->edid);
 678         kfree(radeon_connector->con_priv);
 679         drm_sysfs_connector_remove(connector);
 680         drm_connector_cleanup(connector);
 681         kfree(connector);
 682 }
 683
 684 static int radeon_lvds_set_property(struct drm_connector *connector,
 685                                     struct drm_property *property,
 686                                     uint64_t value)
 687 {
 688         struct drm_device *dev = connector->dev;
 689         struct radeon_encoder *radeon_encoder;
 690         enum radeon_rmx_type rmx_type;
 691
 692         DRM_DEBUG_KMS("\n");
 693         if (property != dev->mode_config.scaling_mode_property)
 694                 return 0;
 695
 696         if (connector->encoder)
 697                 radeon_encoder = to_radeon_encoder(connector->encoder);
 698         else {
 699                 struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
 700                 radeon_encoder = to_radeon_encoder(connector_funcs->best_encoder(connector));
 701         }
 702
 703         switch (value) {
 704         case DRM_MODE_SCALE_NONE: rmx_type = RMX_OFF; break;
 705         case DRM_MODE_SCALE_CENTER: rmx_type = RMX_CENTER; break;
 706         case DRM_MODE_SCALE_ASPECT: rmx_type = RMX_ASPECT; break;
 707         default:
 708         case DRM_MODE_SCALE_FULLSCREEN: rmx_type = RMX_FULL; break;
 709         }
 710         if (radeon_encoder->rmx_type == rmx_type)
 711                 return 0;
 712
 713         radeon_encoder->rmx_type = rmx_type;
 714
 715         radeon_property_change_mode(&radeon_encoder->base);
 716         return 0;
 717 }
 718
 719
 720 static const struct drm_connector_helper_funcs radeon_lvds_connector_helper_funcs = {
 721         .get_modes = radeon_lvds_get_modes,
 722         .mode_valid = radeon_lvds_mode_valid,
 723         .best_encoder = radeon_best_single_encoder,
 724 };
 725
 726 static const struct drm_connector_funcs radeon_lvds_connector_funcs = {
 727         .dpms = drm_helper_connector_dpms,
 728         .detect = radeon_lvds_detect,
 729         .fill_modes = drm_helper_probe_single_connector_modes,
 730         .destroy = radeon_connector_destroy,
 731         .set_property = radeon_lvds_set_property,
 732 };
 733
 734 static int radeon_vga_get_modes(struct drm_connector *connector)
 735 {
 736         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 737         int ret;
 738
 739         ret = radeon_ddc_get_modes(radeon_connector);
 740
 741         return ret;
 742 }
 743
 744 static int radeon_vga_mode_valid(struct drm_connector *connector,
 745                                   struct drm_display_mode *mode)
 746 {
 747         struct drm_device *dev = connector->dev;
 748         struct radeon_device *rdev = dev->dev_private;
 749
 750         /* XXX check mode bandwidth */
 751
 752         if ((mode->clock / 10) > rdev->clock.max_pixel_clock)
 753                 return MODE_CLOCK_HIGH;
 754
 755         return MODE_OK;
 756 }
 757
 758 static enum drm_connector_status
 759 radeon_vga_detect(struct drm_connector *connector, bool force)
 760 {
 761         struct drm_device *dev = connector->dev;
 762         struct radeon_device *rdev = dev->dev_private;
 763         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 764         struct drm_encoder *encoder;
 765         struct drm_encoder_helper_funcs *encoder_funcs;
 766         bool dret = false;
 767         enum drm_connector_status ret = connector_status_disconnected;
 768         int r;
 769
 770         r = pm_runtime_get_sync(connector->dev->dev);
 771         if (r < 0)
 772                 return connector_status_disconnected;
 773
 774         encoder = radeon_best_single_encoder(connector);
 775         if (!encoder)
 776                 ret = connector_status_disconnected;
 777
 778         if (radeon_connector->ddc_bus)
 779                 dret = radeon_ddc_probe(radeon_connector, false);
 780         if (dret) {
 781                 radeon_connector->detected_by_load = false;
 782                 if (radeon_connector->edid) {
 783                         kfree(radeon_connector->edid);
 784                         radeon_connector->edid = NULL;
 785                 }
 786                 radeon_connector->edid = drm_get_edid(&radeon_connector->base, &radeon_connector->ddc_bus->adapter);
 787
 788                 if (!radeon_connector->edid) {
 789                         DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
 790                                         drm_get_connector_name(connector));
 791                         ret = connector_status_connected;
 792                 } else {
 793                         radeon_connector->use_digital = !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
 794
 795                         /* some oems have boards with separate digital and analog connectors
 796                          * with a shared ddc line (often vga + hdmi)
 797                          */
 798                         if (radeon_connector->use_digital && radeon_connector->shared_ddc) {
 799                                 kfree(radeon_connector->edid);
 800                                 radeon_connector->edid = NULL;
 801                                 ret = connector_status_disconnected;
 802                         } else
 803                                 ret = connector_status_connected;
 804                 }
 805         } else {
 806
 807                 /* if we aren't forcing don't do destructive polling */
 808                 if (!force) {
 809                         /* only return the previous status if we last
 810                          * detected a monitor via load.
 811                          */
 812                         if (radeon_connector->detected_by_load)
 813                                 ret = connector->status;
 814                         goto out;
 815                 }
 816
 817                 if (radeon_connector->dac_load_detect && encoder) {
 818                         encoder_funcs = encoder->helper_private;
 819                         ret = encoder_funcs->detect(encoder, connector);
 820                         if (ret != connector_status_disconnected)
 821                                 radeon_connector->detected_by_load = true;
 822                 }
 823         }
 824
 825         if (ret == connector_status_connected)
 826                 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
 827
 828         /* RN50 and some RV100 asics in servers often have a hardcoded EDID in the
 829          * vbios to deal with KVMs. If we have one and are not able to detect a monitor
 830          * by other means, assume the CRT is connected and use that EDID.
 831          */
 832         if ((!rdev->is_atom_bios) &&
 833             (ret == connector_status_disconnected) &&
 834             rdev->mode_info.bios_hardcoded_edid_size) {
 835                 ret = connector_status_connected;
 836         }
 837
 838         radeon_connector_update_scratch_regs(connector, ret);
 839
 840 out:
 841         pm_runtime_mark_last_busy(connector->dev->dev);
 842         pm_runtime_put_autosuspend(connector->dev->dev);
 843
 844         return ret;
 845 }
 846
 847 static const struct drm_connector_helper_funcs radeon_vga_connector_helper_funcs = {
 848         .get_modes = radeon_vga_get_modes,
 849         .mode_valid = radeon_vga_mode_valid,
 850         .best_encoder = radeon_best_single_encoder,
 851 };
 852
 853 static const struct drm_connector_funcs radeon_vga_connector_funcs = {
 854         .dpms = drm_helper_connector_dpms,
 855         .detect = radeon_vga_detect,
 856         .fill_modes = drm_helper_probe_single_connector_modes,
 857         .destroy = radeon_connector_destroy,
 858         .set_property = radeon_connector_set_property,
 859 };
 860
 861 static int radeon_tv_get_modes(struct drm_connector *connector)
 862 {
 863         struct drm_device *dev = connector->dev;
 864         struct radeon_device *rdev = dev->dev_private;
 865         struct drm_display_mode *tv_mode;
 866         struct drm_encoder *encoder;
 867
 868         encoder = radeon_best_single_encoder(connector);
 869         if (!encoder)
 870                 return 0;
 871
 872         /* avivo chips can scale any mode */
 873         if (rdev->family >= CHIP_RS600)
 874                 /* add scaled modes */
 875                 radeon_add_common_modes(encoder, connector);
 876         else {
 877                 /* only 800x600 is supported right now on pre-avivo chips */
 878                 tv_mode = drm_cvt_mode(dev, 800, 600, 60, false, false, false);
 879                 tv_mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
 880                 drm_mode_probed_add(connector, tv_mode);
 881         }
 882         return 1;
 883 }
 884
 885 static int radeon_tv_mode_valid(struct drm_connector *connector,
 886                                 struct drm_display_mode *mode)
 887 {
 888         if ((mode->hdisplay > 1024) || (mode->vdisplay > 768))
 889                 return MODE_CLOCK_RANGE;
 890         return MODE_OK;
 891 }
 892
 893 static enum drm_connector_status
 894 radeon_tv_detect(struct drm_connector *connector, bool force)
 895 {
 896         struct drm_encoder *encoder;
 897         struct drm_encoder_helper_funcs *encoder_funcs;
 898         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 899         enum drm_connector_status ret = connector_status_disconnected;
 900         int r;
 901
 902         if (!radeon_connector->dac_load_detect)
 903                 return ret;
 904
 905         r = pm_runtime_get_sync(connector->dev->dev);
 906         if (r < 0)
 907                 return connector_status_disconnected;
 908
 909         encoder = radeon_best_single_encoder(connector);
 910         if (!encoder)
 911                 ret = connector_status_disconnected;
 912         else {
 913                 encoder_funcs = encoder->helper_private;
 914                 ret = encoder_funcs->detect(encoder, connector);
 915         }
 916         if (ret == connector_status_connected)
 917                 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, false);
 918         radeon_connector_update_scratch_regs(connector, ret);
 919         pm_runtime_mark_last_busy(connector->dev->dev);
 920         pm_runtime_put_autosuspend(connector->dev->dev);
 921         return ret;
 922 }
 923
 924 static const struct drm_connector_helper_funcs radeon_tv_connector_helper_funcs = {
 925         .get_modes = radeon_tv_get_modes,
 926         .mode_valid = radeon_tv_mode_valid,
 927         .best_encoder = radeon_best_single_encoder,
 928 };
 929
 930 static const struct drm_connector_funcs radeon_tv_connector_funcs = {
 931         .dpms = drm_helper_connector_dpms,
 932         .detect = radeon_tv_detect,
 933         .fill_modes = drm_helper_probe_single_connector_modes,
 934         .destroy = radeon_connector_destroy,
 935         .set_property = radeon_connector_set_property,
 936 };
 937
 938 static int radeon_dvi_get_modes(struct drm_connector *connector)
 939 {
 940         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 941         int ret;
 942
 943         ret = radeon_ddc_get_modes(radeon_connector);
 944         return ret;
 945 }
 946
 947 static bool radeon_check_hpd_status_unchanged(struct drm_connector *connector)
 948 {
 949         struct drm_device *dev = connector->dev;
 950         struct radeon_device *rdev = dev->dev_private;
 951         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 952         enum drm_connector_status status;
 953
 954         /* We only trust HPD on R600 and newer ASICS. */
 955         if (rdev->family >= CHIP_R600
 956           && radeon_connector->hpd.hpd != RADEON_HPD_NONE) {
 957                 if (radeon_hpd_sense(rdev, radeon_connector->hpd.hpd))
 958                         status = connector_status_connected;
 959                 else
 960                         status = connector_status_disconnected;
 961                 if (connector->status == status)
 962                         return true;
 963         }
 964
 965         return false;
 966 }
 967
 968 /*
 969  * DVI is complicated
 970  * Do a DDC probe, if DDC probe passes, get the full EDID so
 971  * we can do analog/digital monitor detection at this point.
 972  * If the monitor is an analog monitor or we got no DDC,
 973  * we need to find the DAC encoder object for this connector.
 974  * If we got no DDC, we do load detection on the DAC encoder object.
 975  * If we got analog DDC or load detection passes on the DAC encoder
 976  * we have to check if this analog encoder is shared with anyone else (TV)
 977  * if its shared we have to set the other connector to disconnected.
 978  */
 979 static enum drm_connector_status
 980 radeon_dvi_detect(struct drm_connector *connector, bool force)
 981 {
 982         struct drm_device *dev = connector->dev;
 983         struct radeon_device *rdev = dev->dev_private;
 984         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 985         struct drm_encoder *encoder = NULL;
 986         struct drm_encoder_helper_funcs *encoder_funcs;
 987         struct drm_mode_object *obj;
 988         int i, r;
 989         enum drm_connector_status ret = connector_status_disconnected;
 990         bool dret = false, broken_edid = false;
 991
 992         r = pm_runtime_get_sync(connector->dev->dev);
 993         if (r < 0)
 994                 return connector_status_disconnected;
 995
 996         if (!force && radeon_check_hpd_status_unchanged(connector)) {
 997                 ret = connector->status;
 998                 goto exit;
 999         }
1000
1001         if (radeon_connector->ddc_bus)
1002                 dret = radeon_ddc_probe(radeon_connector, false);
1003         if (dret) {
1004                 radeon_connector->detected_by_load = false;
1005                 if (radeon_connector->edid) {
1006                         kfree(radeon_connector->edid);
1007                         radeon_connector->edid = NULL;
1008                 }
1009                 radeon_connector->edid = drm_get_edid(&radeon_connector->base, &radeon_connector->ddc_bus->adapter);
1010
1011                 if (!radeon_connector->edid) {
1012                         DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
1013                                         drm_get_connector_name(connector));
1014                         /* rs690 seems to have a problem with connectors not existing and always
1015                          * return a block of 0's. If we see this just stop polling on this output */
1016                         if ((rdev->family == CHIP_RS690 || rdev->family == CHIP_RS740) && radeon_connector->base.null_edid_counter) {
1017                                 ret = connector_status_disconnected;
1018                                 DRM_ERROR("%s: detected RS690 floating bus bug, stopping ddc detect\n", drm_get_connector_name(connector));
1019                                 radeon_connector->ddc_bus = NULL;
1020                         } else {
1021                                 ret = connector_status_connected;
1022                                 broken_edid = true; /* defer use_digital to later */
1023                         }
1024                 } else {
1025                         radeon_connector->use_digital = !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
1026
1027                         /* some oems have boards with separate digital and analog connectors
1028                          * with a shared ddc line (often vga + hdmi)
1029                          */
1030                         if ((!radeon_connector->use_digital) && radeon_connector->shared_ddc) {
1031                                 kfree(radeon_connector->edid);
1032                                 radeon_connector->edid = NULL;
1033                                 ret = connector_status_disconnected;
1034                         } else
1035                                 ret = connector_status_connected;
1036
1037                         /* This gets complicated.  We have boards with VGA + HDMI with a
1038                          * shared DDC line and we have boards with DVI-D + HDMI with a shared
1039                          * DDC line.  The latter is more complex because with DVI<->HDMI adapters
1040                          * you don't really know what's connected to which port as both are digital.
1041                          */
1042                         if (radeon_connector->shared_ddc && (ret == connector_status_connected)) {
1043                                 struct drm_connector *list_connector;
1044                                 struct radeon_connector *list_radeon_connector;
1045                                 list_for_each_entry(list_connector, &dev->mode_config.connector_list, head) {
1046                                         if (connector == list_connector)
1047                                                 continue;
1048                                         list_radeon_connector = to_radeon_connector(list_connector);
1049                                         if (list_radeon_connector->shared_ddc &&
1050                                             (list_radeon_connector->ddc_bus->rec.i2c_id ==
1051                                              radeon_connector->ddc_bus->rec.i2c_id)) {
1052                                                 /* cases where both connectors are digital */
1053                                                 if (list_connector->connector_type != DRM_MODE_CONNECTOR_VGA) {
1054                                                         /* hpd is our only option in this case */
1055                                                         if (!radeon_hpd_sense(rdev, radeon_connector->hpd.hpd)) {
1056                                                                 kfree(radeon_connector->edid);
1057                                                                 radeon_connector->edid = NULL;
1058                                                                 ret = connector_status_disconnected;
1059                                                         }
1060                                                 }
1061                                         }
1062                                 }
1063                         }
1064                 }
1065         }
1066
1067         if ((ret == connector_status_connected) && (radeon_connector->use_digital == true))
1068                 goto out;
1069
1070         /* DVI-D and HDMI-A are digital only */
1071         if ((connector->connector_type == DRM_MODE_CONNECTOR_DVID) ||
1072             (connector->connector_type == DRM_MODE_CONNECTOR_HDMIA))
1073                 goto out;
1074
1075         /* if we aren't forcing don't do destructive polling */
1076         if (!force) {
1077                 /* only return the previous status if we last
1078                  * detected a monitor via load.
1079                  */
1080                 if (radeon_connector->detected_by_load)
1081                         ret = connector->status;
1082                 goto out;
1083         }
1084
1085         /* find analog encoder */
1086         if (radeon_connector->dac_load_detect) {
1087                 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
1088                         if (connector->encoder_ids[i] == 0)
1089                                 break;
1090
1091                         obj = drm_mode_object_find(connector->dev,
1092                                                    connector->encoder_ids[i],
1093                                                    DRM_MODE_OBJECT_ENCODER);
1094                         if (!obj)
1095                                 continue;
1096
1097                         encoder = obj_to_encoder(obj);
1098
1099                         if (encoder->encoder_type != DRM_MODE_ENCODER_DAC &&
1100                             encoder->encoder_type != DRM_MODE_ENCODER_TVDAC)
1101                                 continue;
1102
1103                         encoder_funcs = encoder->helper_private;
1104                         if (encoder_funcs->detect) {
1105                                 if (!broken_edid) {
1106                                         if (ret != connector_status_connected) {
1107                                                 /* deal with analog monitors without DDC */
1108                                                 ret = encoder_funcs->detect(encoder, connector);
1109                                                 if (ret == connector_status_connected) {
1110                                                         radeon_connector->use_digital = false;
1111                                                 }
1112                                                 if (ret != connector_status_disconnected)
1113                                                         radeon_connector->detected_by_load = true;
1114                                         }
1115                                 } else {
1116                                         enum drm_connector_status lret;
1117                                         /* assume digital unless load detected otherwise */
1118                                         radeon_connector->use_digital = true;
1119                                         lret = encoder_funcs->detect(encoder, connector);
1120                                         DRM_DEBUG_KMS("load_detect %x returned: %x\n",encoder->encoder_type,lret);
1121                                         if (lret == connector_status_connected)
1122                                                 radeon_connector->use_digital = false;
1123                                 }
1124                                 break;
1125                         }
1126                 }
1127         }
1128
1129         if ((ret == connector_status_connected) && (radeon_connector->use_digital == false) &&
1130             encoder) {
1131                 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
1132         }
1133
1134         /* RN50 and some RV100 asics in servers often have a hardcoded EDID in the
1135          * vbios to deal with KVMs. If we have one and are not able to detect a monitor
1136          * by other means, assume the DFP is connected and use that EDID.  In most
1137          * cases the DVI port is actually a virtual KVM port connected to the service
1138          * processor.
1139          */
1140 out:
1141         if ((!rdev->is_atom_bios) &&
1142             (ret == connector_status_disconnected) &&
1143             rdev->mode_info.bios_hardcoded_edid_size) {
1144                 radeon_connector->use_digital = true;
1145                 ret = connector_status_connected;
1146         }
1147
1148         /* updated in get modes as well since we need to know if it's analog or digital */
1149         radeon_connector_update_scratch_regs(connector, ret);
1150
1151 exit:
1152         pm_runtime_mark_last_busy(connector->dev->dev);
1153         pm_runtime_put_autosuspend(connector->dev->dev);
1154
1155         return ret;
1156 }
1157
1158 /* okay need to be smart in here about which encoder to pick */
1159 static struct drm_encoder *radeon_dvi_encoder(struct drm_connector *connector)
1160 {
1161         int enc_id = connector->encoder_ids[0];
1162         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1163         struct drm_mode_object *obj;
1164         struct drm_encoder *encoder;
1165         int i;
1166         for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
1167                 if (connector->encoder_ids[i] == 0)
1168                         break;
1169
1170                 obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER);
1171                 if (!obj)
1172                         continue;
1173
1174                 encoder = obj_to_encoder(obj);
1175
1176                 if (radeon_connector->use_digital == true) {
1177                         if (encoder->encoder_type == DRM_MODE_ENCODER_TMDS)
1178                                 return encoder;
1179                 } else {
1180                         if (encoder->encoder_type == DRM_MODE_ENCODER_DAC ||
1181                             encoder->encoder_type == DRM_MODE_ENCODER_TVDAC)
1182                                 return encoder;
1183                 }
1184         }
1185
1186         /* see if we have a default encoder  TODO */
1187
1188         /* then check use digitial */
1189         /* pick the first one */
1190         if (enc_id) {
1191                 obj = drm_mode_object_find(connector->dev, enc_id, DRM_MODE_OBJECT_ENCODER);
1192                 if (!obj)
1193                         return NULL;
1194                 encoder = obj_to_encoder(obj);
1195                 return encoder;
1196         }
1197         return NULL;
1198 }
1199
1200 static void radeon_dvi_force(struct drm_connector *connector)
1201 {
1202         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1203         if (connector->force == DRM_FORCE_ON)
1204                 radeon_connector->use_digital = false;
1205         if (connector->force == DRM_FORCE_ON_DIGITAL)
1206                 radeon_connector->use_digital = true;
1207 }
1208
1209 static int radeon_dvi_mode_valid(struct drm_connector *connector,
1210                                   struct drm_display_mode *mode)
1211 {
1212         struct drm_device *dev = connector->dev;
1213         struct radeon_device *rdev = dev->dev_private;
1214         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1215
1216         /* XXX check mode bandwidth */
1217
1218         /* clocks over 135 MHz have heat issues with DVI on RV100 */
1219         if (radeon_connector->use_digital &&
1220             (rdev->family == CHIP_RV100) &&
1221             (mode->clock > 135000))
1222                 return MODE_CLOCK_HIGH;
1223
1224         if (radeon_connector->use_digital && (mode->clock > 165000)) {
1225                 if ((radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_I) ||
1226                     (radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_D) ||
1227                     (radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_HDMI_TYPE_B))
1228                         return MODE_OK;
1229                 else if (radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_HDMI_TYPE_A) {
1230                         if (ASIC_IS_DCE6(rdev)) {
1231                                 /* HDMI 1.3+ supports max clock of 340 Mhz */
1232                                 if (mode->clock > 340000)
1233                                         return MODE_CLOCK_HIGH;
1234                                 else
1235                                         return MODE_OK;
1236                         } else
1237                                 return MODE_CLOCK_HIGH;
1238                 } else
1239                         return MODE_CLOCK_HIGH;
1240         }
1241
1242         /* check against the max pixel clock */
1243         if ((mode->clock / 10) > rdev->clock.max_pixel_clock)
1244                 return MODE_CLOCK_HIGH;
1245
1246         return MODE_OK;
1247 }
1248
1249 static const struct drm_connector_helper_funcs radeon_dvi_connector_helper_funcs = {
1250         .get_modes = radeon_dvi_get_modes,
1251         .mode_valid = radeon_dvi_mode_valid,
1252         .best_encoder = radeon_dvi_encoder,
1253 };
1254
1255 static const struct drm_connector_funcs radeon_dvi_connector_funcs = {
1256         .dpms = drm_helper_connector_dpms,
1257         .detect = radeon_dvi_detect,
1258         .fill_modes = drm_helper_probe_single_connector_modes,
1259         .set_property = radeon_connector_set_property,
1260         .destroy = radeon_connector_destroy,
1261         .force = radeon_dvi_force,
1262 };
1263
1264 static void radeon_dp_connector_destroy(struct drm_connector *connector)
1265 {
1266         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1267         struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
1268
1269         if (radeon_connector->edid)
1270                 kfree(radeon_connector->edid);
1271         if (radeon_dig_connector->dp_i2c_bus)
1272                 radeon_i2c_destroy(radeon_dig_connector->dp_i2c_bus);
1273         kfree(radeon_connector->con_priv);
1274         drm_sysfs_connector_remove(connector);
1275         drm_connector_cleanup(connector);
1276         kfree(connector);
1277 }
1278
1279 static int radeon_dp_get_modes(struct drm_connector *connector)
1280 {
1281         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1282         struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
1283         struct drm_encoder *encoder = radeon_best_single_encoder(connector);
1284         int ret;
1285
1286         if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) ||
1287             (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
1288                 struct drm_display_mode *mode;
1289
1290                 if (connector->connector_type == DRM_MODE_CONNECTOR_eDP) {
1291                         if (!radeon_dig_connector->edp_on)
1292                                 atombios_set_edp_panel_power(connector,
1293                                                              ATOM_TRANSMITTER_ACTION_POWER_ON);
1294                         ret = radeon_ddc_get_modes(radeon_connector);
1295                         if (!radeon_dig_connector->edp_on)
1296                                 atombios_set_edp_panel_power(connector,
1297                                                              ATOM_TRANSMITTER_ACTION_POWER_OFF);
1298                 } else {
1299                         /* need to setup ddc on the bridge */
1300                         if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
1301                             ENCODER_OBJECT_ID_NONE) {
1302                                 if (encoder)
1303                                         radeon_atom_ext_encoder_setup_ddc(encoder);
1304                         }
1305                         ret = radeon_ddc_get_modes(radeon_connector);
1306                 }
1307
1308                 if (ret > 0) {
1309                         if (encoder) {
1310                                 radeon_fixup_lvds_native_mode(encoder, connector);
1311                                 /* add scaled modes */
1312                                 radeon_add_common_modes(encoder, connector);
1313                         }
1314                         return ret;
1315                 }
1316
1317                 if (!encoder)
1318                         return 0;
1319
1320                 /* we have no EDID modes */
1321                 mode = radeon_fp_native_mode(encoder);
1322                 if (mode) {
1323                         ret = 1;
1324                         drm_mode_probed_add(connector, mode);
1325                         /* add the width/height from vbios tables if available */
1326                         connector->display_info.width_mm = mode->width_mm;
1327                         connector->display_info.height_mm = mode->height_mm;
1328                         /* add scaled modes */
1329                         radeon_add_common_modes(encoder, connector);
1330                 }
1331         } else {
1332                 /* need to setup ddc on the bridge */
1333                 if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
1334                         ENCODER_OBJECT_ID_NONE) {
1335                         if (encoder)
1336                                 radeon_atom_ext_encoder_setup_ddc(encoder);
1337                 }
1338                 ret = radeon_ddc_get_modes(radeon_connector);
1339         }
1340
1341         return ret;
1342 }
1343
1344 u16 radeon_connector_encoder_get_dp_bridge_encoder_id(struct drm_connector *connector)
1345 {
1346         struct drm_mode_object *obj;
1347         struct drm_encoder *encoder;
1348         struct radeon_encoder *radeon_encoder;
1349         int i;
1350
1351         for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
1352                 if (connector->encoder_ids[i] == 0)
1353                         break;
1354
1355                 obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER);
1356                 if (!obj)
1357                         continue;
1358
1359                 encoder = obj_to_encoder(obj);
1360                 radeon_encoder = to_radeon_encoder(encoder);
1361
1362                 switch (radeon_encoder->encoder_id) {
1363                 case ENCODER_OBJECT_ID_TRAVIS:
1364                 case ENCODER_OBJECT_ID_NUTMEG:
1365                         return radeon_encoder->encoder_id;
1366                 default:
1367                         break;
1368                 }
1369         }
1370
1371         return ENCODER_OBJECT_ID_NONE;
1372 }
1373
1374 bool radeon_connector_encoder_is_hbr2(struct drm_connector *connector)
1375 {
1376         struct drm_mode_object *obj;
1377         struct drm_encoder *encoder;
1378         struct radeon_encoder *radeon_encoder;
1379         int i;
1380         bool found = false;
1381
1382         for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
1383                 if (connector->encoder_ids[i] == 0)
1384                         break;
1385
1386                 obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER);
1387                 if (!obj)
1388                         continue;
1389
1390                 encoder = obj_to_encoder(obj);
1391                 radeon_encoder = to_radeon_encoder(encoder);
1392                 if (radeon_encoder->caps & ATOM_ENCODER_CAP_RECORD_HBR2)
1393                         found = true;
1394         }
1395
1396         return found;
1397 }
1398
1399 bool radeon_connector_is_dp12_capable(struct drm_connector *connector)
1400 {
1401         struct drm_device *dev = connector->dev;
1402         struct radeon_device *rdev = dev->dev_private;
1403
1404         if (ASIC_IS_DCE5(rdev) &&
1405             (rdev->clock.dp_extclk >= 53900) &&
1406             radeon_connector_encoder_is_hbr2(connector)) {
1407                 return true;
1408         }
1409
1410         return false;
1411 }
1412
1413 static enum drm_connector_status
1414 radeon_dp_detect(struct drm_connector *connector, bool force)
1415 {
1416         struct drm_device *dev = connector->dev;
1417         struct radeon_device *rdev = dev->dev_private;
1418         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1419         enum drm_connector_status ret = connector_status_disconnected;
1420         struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
1421         struct drm_encoder *encoder = radeon_best_single_encoder(connector);
1422         int r;
1423
1424         r = pm_runtime_get_sync(connector->dev->dev);
1425         if (r < 0)
1426                 return connector_status_disconnected;
1427
1428         if (!force && radeon_check_hpd_status_unchanged(connector)) {
1429                 ret = connector->status;
1430                 goto out;
1431         }
1432
1433         if (radeon_connector->edid) {
1434                 kfree(radeon_connector->edid);
1435                 radeon_connector->edid = NULL;
1436         }
1437
1438         if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) ||
1439             (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
1440                 if (encoder) {
1441                         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
1442                         struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
1443
1444                         /* check if panel is valid */
1445                         if (native_mode->hdisplay >= 320 && native_mode->vdisplay >= 240)
1446                                 ret = connector_status_connected;
1447                 }
1448                 /* eDP is always DP */
1449                 radeon_dig_connector->dp_sink_type = CONNECTOR_OBJECT_ID_DISPLAYPORT;
1450                 if (!radeon_dig_connector->edp_on)
1451                         atombios_set_edp_panel_power(connector,
1452                                                      ATOM_TRANSMITTER_ACTION_POWER_ON);
1453                 if (radeon_dp_getdpcd(radeon_connector))
1454                         ret = connector_status_connected;
1455                 if (!radeon_dig_connector->edp_on)
1456                         atombios_set_edp_panel_power(connector,
1457                                                      ATOM_TRANSMITTER_ACTION_POWER_OFF);
1458         } else if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
1459                    ENCODER_OBJECT_ID_NONE) {
1460                 /* DP bridges are always DP */
1461                 radeon_dig_connector->dp_sink_type = CONNECTOR_OBJECT_ID_DISPLAYPORT;
1462                 /* get the DPCD from the bridge */
1463                 radeon_dp_getdpcd(radeon_connector);
1464
1465                 if (encoder) {
1466                         /* setup ddc on the bridge */
1467                         radeon_atom_ext_encoder_setup_ddc(encoder);
1468                         /* bridge chips are always aux */
1469                         if (radeon_ddc_probe(radeon_connector, true)) /* try DDC */
1470                                 ret = connector_status_connected;
1471                         else if (radeon_connector->dac_load_detect) { /* try load detection */
1472                                 struct drm_encoder_helper_funcs *encoder_funcs = encoder->helper_private;
1473                                 ret = encoder_funcs->detect(encoder, connector);
1474                         }
1475                 }
1476         } else {
1477                 radeon_dig_connector->dp_sink_type = radeon_dp_getsinktype(radeon_connector);
1478                 if (radeon_hpd_sense(rdev, radeon_connector->hpd.hpd)) {
1479                         ret = connector_status_connected;
1480                         if (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT)
1481                                 radeon_dp_getdpcd(radeon_connector);
1482                 } else {
1483                         if (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) {
1484                                 if (radeon_dp_getdpcd(radeon_connector))
1485                                         ret = connector_status_connected;
1486                         } else {
1487                                 /* try non-aux ddc (DP to DVI/HDMI/etc. adapter) */
1488                                 if (radeon_ddc_probe(radeon_connector, false))
1489                                         ret = connector_status_connected;
1490                         }
1491                 }
1492         }
1493
1494         radeon_connector_update_scratch_regs(connector, ret);
1495 out:
1496         pm_runtime_mark_last_busy(connector->dev->dev);
1497         pm_runtime_put_autosuspend(connector->dev->dev);
1498
1499         return ret;
1500 }
1501
1502 static int radeon_dp_mode_valid(struct drm_connector *connector,
1503                                   struct drm_display_mode *mode)
1504 {
1505         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1506         struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
1507
1508         /* XXX check mode bandwidth */
1509
1510         if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) ||
1511             (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
1512                 struct drm_encoder *encoder = radeon_best_single_encoder(connector);
1513
1514                 if ((mode->hdisplay < 320) || (mode->vdisplay < 240))
1515                         return MODE_PANEL;
1516
1517                 if (encoder) {
1518                         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
1519                         struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
1520
1521                         /* AVIVO hardware supports downscaling modes larger than the panel
1522                          * to the panel size, but I'm not sure this is desirable.
1523                          */
1524                         if ((mode->hdisplay > native_mode->hdisplay) ||
1525                             (mode->vdisplay > native_mode->vdisplay))
1526                                 return MODE_PANEL;
1527
1528                         /* if scaling is disabled, block non-native modes */
1529                         if (radeon_encoder->rmx_type == RMX_OFF) {
1530                                 if ((mode->hdisplay != native_mode->hdisplay) ||
1531                                     (mode->vdisplay != native_mode->vdisplay))
1532                                         return MODE_PANEL;
1533                         }
1534                 }
1535                 return MODE_OK;
1536         } else {
1537                 if ((radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) ||
1538                     (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_eDP))
1539                         return radeon_dp_mode_valid_helper(connector, mode);
1540                 else
1541                         return MODE_OK;
1542         }
1543 }
1544
1545 static const struct drm_connector_helper_funcs radeon_dp_connector_helper_funcs = {
1546         .get_modes = radeon_dp_get_modes,
1547         .mode_valid = radeon_dp_mode_valid,
1548         .best_encoder = radeon_dvi_encoder,
1549 };
1550
1551 static const struct drm_connector_funcs radeon_dp_connector_funcs = {
1552         .dpms = drm_helper_connector_dpms,
1553         .detect = radeon_dp_detect,
1554         .fill_modes = drm_helper_probe_single_connector_modes,
1555         .set_property = radeon_connector_set_property,
1556         .destroy = radeon_dp_connector_destroy,
1557         .force = radeon_dvi_force,
1558 };
1559
1560 static const struct drm_connector_funcs radeon_edp_connector_funcs = {
1561         .dpms = drm_helper_connector_dpms,
1562         .detect = radeon_dp_detect,
1563         .fill_modes = drm_helper_probe_single_connector_modes,
1564         .set_property = radeon_lvds_set_property,
1565         .destroy = radeon_dp_connector_destroy,
1566         .force = radeon_dvi_force,
1567 };
1568
1569 static const struct drm_connector_funcs radeon_lvds_bridge_connector_funcs = {
1570         .dpms = drm_helper_connector_dpms,
1571         .detect = radeon_dp_detect,
1572         .fill_modes = drm_helper_probe_single_connector_modes,
1573         .set_property = radeon_lvds_set_property,
1574         .destroy = radeon_dp_connector_destroy,
1575         .force = radeon_dvi_force,
1576 };
1577
1578 void
1579 radeon_add_atom_connector(struct drm_device *dev,
1580                           uint32_t connector_id,
1581                           uint32_t supported_device,
1582                           int connector_type,
1583                           struct radeon_i2c_bus_rec *i2c_bus,
1584                           uint32_t igp_lane_info,
1585                           uint16_t connector_object_id,
1586                           struct radeon_hpd *hpd,
1587                           struct radeon_router *router)
1588 {
1589         struct radeon_device *rdev = dev->dev_private;
1590         struct drm_connector *connector;
1591         struct radeon_connector *radeon_connector;
1592         struct radeon_connector_atom_dig *radeon_dig_connector;
1593         struct drm_encoder *encoder;
1594         struct radeon_encoder *radeon_encoder;
1595         uint32_t subpixel_order = SubPixelNone;
1596         bool shared_ddc = false;
1597         bool is_dp_bridge = false;
1598         bool has_aux = false;
1599
1600         if (connector_type == DRM_MODE_CONNECTOR_Unknown)
1601                 return;
1602
1603         /* if the user selected tv=0 don't try and add the connector */
1604         if (((connector_type == DRM_MODE_CONNECTOR_SVIDEO) ||
1605              (connector_type == DRM_MODE_CONNECTOR_Composite) ||
1606              (connector_type == DRM_MODE_CONNECTOR_9PinDIN)) &&
1607             (radeon_tv == 0))
1608                 return;
1609
1610         /* see if we already added it */
1611         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
1612                 radeon_connector = to_radeon_connector(connector);
1613                 if (radeon_connector->connector_id == connector_id) {
1614                         radeon_connector->devices |= supported_device;
1615                         return;
1616                 }
1617                 if (radeon_connector->ddc_bus && i2c_bus->valid) {
1618                         if (radeon_connector->ddc_bus->rec.i2c_id == i2c_bus->i2c_id) {
1619                                 radeon_connector->shared_ddc = true;
1620                                 shared_ddc = true;
1621                         }
1622                         if (radeon_connector->router_bus && router->ddc_valid &&
1623                             (radeon_connector->router.router_id == router->router_id)) {
1624                                 radeon_connector->shared_ddc = false;
1625                                 shared_ddc = false;
1626                         }
1627                 }
1628         }
1629
1630         /* check if it's a dp bridge */
1631         list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
1632                 radeon_encoder = to_radeon_encoder(encoder);
1633                 if (radeon_encoder->devices & supported_device) {
1634                         switch (radeon_encoder->encoder_id) {
1635                         case ENCODER_OBJECT_ID_TRAVIS:
1636                         case ENCODER_OBJECT_ID_NUTMEG:
1637                                 is_dp_bridge = true;
1638                                 break;
1639                         default:
1640                                 break;
1641                         }
1642                 }
1643         }
1644
1645         radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
1646         if (!radeon_connector)
1647                 return;
1648
1649         connector = &radeon_connector->base;
1650
1651         radeon_connector->connector_id = connector_id;
1652         radeon_connector->devices = supported_device;
1653         radeon_connector->shared_ddc = shared_ddc;
1654         radeon_connector->connector_object_id = connector_object_id;
1655         radeon_connector->hpd = *hpd;
1656
1657         radeon_connector->router = *router;
1658         if (router->ddc_valid || router->cd_valid) {
1659                 radeon_connector->router_bus = radeon_i2c_lookup(rdev, &router->i2c_info);
1660                 if (!radeon_connector->router_bus)
1661                         DRM_ERROR("Failed to assign router i2c bus! Check dmesg for i2c errors.\n");
1662         }
1663
1664         if (is_dp_bridge) {
1665                 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
1666                 if (!radeon_dig_connector)
1667                         goto failed;
1668                 radeon_dig_connector->igp_lane_info = igp_lane_info;
1669                 radeon_connector->con_priv = radeon_dig_connector;
1670                 if (i2c_bus->valid) {
1671                         /* add DP i2c bus */
1672                         if (connector_type == DRM_MODE_CONNECTOR_eDP)
1673                                 radeon_dig_connector->dp_i2c_bus = radeon_i2c_create_dp(dev, i2c_bus, "eDP-auxch");
1674                         else
1675                                 radeon_dig_connector->dp_i2c_bus = radeon_i2c_create_dp(dev, i2c_bus, "DP-auxch");
1676                         if (radeon_dig_connector->dp_i2c_bus)
1677                                 has_aux = true;
1678                         else
1679                                 DRM_ERROR("DP: Failed to assign dp ddc bus! Check dmesg for i2c errors.\n");
1680                         radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1681                         if (!radeon_connector->ddc_bus)
1682                                 DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1683                 }
1684                 switch (connector_type) {
1685                 case DRM_MODE_CONNECTOR_VGA:
1686                 case DRM_MODE_CONNECTOR_DVIA:
1687                 default:
1688                         drm_connector_init(dev, &radeon_connector->base,
1689                                            &radeon_dp_connector_funcs, connector_type);
1690                         drm_connector_helper_add(&radeon_connector->base,
1691                                                  &radeon_dp_connector_helper_funcs);
1692                         connector->interlace_allowed = true;
1693                         connector->doublescan_allowed = true;
1694                         radeon_connector->dac_load_detect = true;
1695                         drm_object_attach_property(&radeon_connector->base.base,
1696                                                       rdev->mode_info.load_detect_property,
1697                                                       1);
1698                         break;
1699                 case DRM_MODE_CONNECTOR_DVII:
1700                 case DRM_MODE_CONNECTOR_DVID:
1701                 case DRM_MODE_CONNECTOR_HDMIA:
1702                 case DRM_MODE_CONNECTOR_HDMIB:
1703                 case DRM_MODE_CONNECTOR_DisplayPort:
1704                         drm_connector_init(dev, &radeon_connector->base,
1705                                            &radeon_dp_connector_funcs, connector_type);
1706                         drm_connector_helper_add(&radeon_connector->base,
1707                                                  &radeon_dp_connector_helper_funcs);
1708                         drm_object_attach_property(&radeon_connector->base.base,
1709                                                       rdev->mode_info.underscan_property,
1710                                                       UNDERSCAN_OFF);
1711                         drm_object_attach_property(&radeon_connector->base.base,
1712                                                       rdev->mode_info.underscan_hborder_property,
1713                                                       0);
1714                         drm_object_attach_property(&radeon_connector->base.base,
1715                                                       rdev->mode_info.underscan_vborder_property,
1716                                                       0);
1717
1718                         drm_object_attach_property(&radeon_connector->base.base,
1719                                                    rdev->mode_info.dither_property,
1720                                                    RADEON_FMT_DITHER_DISABLE);
1721
1722                         if (radeon_audio != 0)
1723                                 drm_object_attach_property(&radeon_connector->base.base,
1724                                                            rdev->mode_info.audio_property,
1725                                                            RADEON_AUDIO_AUTO);
1726
1727                         subpixel_order = SubPixelHorizontalRGB;
1728                         connector->interlace_allowed = true;
1729                         if (connector_type == DRM_MODE_CONNECTOR_HDMIB)
1730                                 connector->doublescan_allowed = true;
1731                         else
1732                                 connector->doublescan_allowed = false;
1733                         if (connector_type == DRM_MODE_CONNECTOR_DVII) {
1734                                 radeon_connector->dac_load_detect = true;
1735                                 drm_object_attach_property(&radeon_connector->base.base,
1736                                                               rdev->mode_info.load_detect_property,
1737                                                               1);
1738                         }
1739                         break;
1740                 case DRM_MODE_CONNECTOR_LVDS:
1741                 case DRM_MODE_CONNECTOR_eDP:
1742                         drm_connector_init(dev, &radeon_connector->base,
1743                                            &radeon_lvds_bridge_connector_funcs, connector_type);
1744                         drm_connector_helper_add(&radeon_connector->base,
1745                                                  &radeon_dp_connector_helper_funcs);
1746                         drm_object_attach_property(&radeon_connector->base.base,
1747                                                       dev->mode_config.scaling_mode_property,
1748                                                       DRM_MODE_SCALE_FULLSCREEN);
1749                         subpixel_order = SubPixelHorizontalRGB;
1750                         connector->interlace_allowed = false;
1751                         connector->doublescan_allowed = false;
1752                         break;
1753                 }
1754         } else {
1755                 switch (connector_type) {
1756                 case DRM_MODE_CONNECTOR_VGA:
1757                         drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1758                         drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1759                         if (i2c_bus->valid) {
1760                                 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1761                                 if (!radeon_connector->ddc_bus)
1762                                         DRM_ERROR("VGA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1763                         }
1764                         radeon_connector->dac_load_detect = true;
1765                         drm_object_attach_property(&radeon_connector->base.base,
1766                                                       rdev->mode_info.load_detect_property,
1767                                                       1);
1768                         /* no HPD on analog connectors */
1769                         radeon_connector->hpd.hpd = RADEON_HPD_NONE;
1770                         connector->polled = DRM_CONNECTOR_POLL_CONNECT;
1771                         connector->interlace_allowed = true;
1772                         connector->doublescan_allowed = true;
1773                         break;
1774                 case DRM_MODE_CONNECTOR_DVIA:
1775                         drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1776                         drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1777                         if (i2c_bus->valid) {
1778                                 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1779                                 if (!radeon_connector->ddc_bus)
1780                                         DRM_ERROR("DVIA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1781                         }
1782                         radeon_connector->dac_load_detect = true;
1783                         drm_object_attach_property(&radeon_connector->base.base,
1784                                                       rdev->mode_info.load_detect_property,
1785                                                       1);
1786                         /* no HPD on analog connectors */
1787                         radeon_connector->hpd.hpd = RADEON_HPD_NONE;
1788                         connector->interlace_allowed = true;
1789                         connector->doublescan_allowed = true;
1790                         break;
1791                 case DRM_MODE_CONNECTOR_DVII:
1792                 case DRM_MODE_CONNECTOR_DVID:
1793                         radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
1794                         if (!radeon_dig_connector)
1795                                 goto failed;
1796                         radeon_dig_connector->igp_lane_info = igp_lane_info;
1797                         radeon_connector->con_priv = radeon_dig_connector;
1798                         drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
1799                         drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
1800                         if (i2c_bus->valid) {
1801                                 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1802                                 if (!radeon_connector->ddc_bus)
1803                                         DRM_ERROR("DVI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1804                         }
1805                         subpixel_order = SubPixelHorizontalRGB;
1806                         drm_object_attach_property(&radeon_connector->base.base,
1807                                                       rdev->mode_info.coherent_mode_property,
1808                                                       1);
1809                         if (ASIC_IS_AVIVO(rdev)) {
1810                                 drm_object_attach_property(&radeon_connector->base.base,
1811                                                               rdev->mode_info.underscan_property,
1812                                                               UNDERSCAN_OFF);
1813                                 drm_object_attach_property(&radeon_connector->base.base,
1814                                                               rdev->mode_info.underscan_hborder_property,
1815                                                               0);
1816                                 drm_object_attach_property(&radeon_connector->base.base,
1817                                                               rdev->mode_info.underscan_vborder_property,
1818                                                               0);
1819                         }
1820                         if (ASIC_IS_DCE2(rdev) && (radeon_audio != 0)) {
1821                                 drm_object_attach_property(&radeon_connector->base.base,
1822                                                            rdev->mode_info.audio_property,
1823                                                            RADEON_AUDIO_AUTO);
1824                         }
1825                         if (ASIC_IS_AVIVO(rdev)) {
1826                                 drm_object_attach_property(&radeon_connector->base.base,
1827                                                            rdev->mode_info.dither_property,
1828                                                            RADEON_FMT_DITHER_DISABLE);
1829                         }
1830                         if (connector_type == DRM_MODE_CONNECTOR_DVII) {
1831                                 radeon_connector->dac_load_detect = true;
1832                                 drm_object_attach_property(&radeon_connector->base.base,
1833                                                               rdev->mode_info.load_detect_property,
1834                                                               1);
1835                         }
1836                         connector->interlace_allowed = true;
1837                         if (connector_type == DRM_MODE_CONNECTOR_DVII)
1838                                 connector->doublescan_allowed = true;
1839                         else
1840                                 connector->doublescan_allowed = false;
1841                         break;
1842                 case DRM_MODE_CONNECTOR_HDMIA:
1843                 case DRM_MODE_CONNECTOR_HDMIB:
1844                         radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
1845                         if (!radeon_dig_connector)
1846                                 goto failed;
1847                         radeon_dig_connector->igp_lane_info = igp_lane_info;
1848                         radeon_connector->con_priv = radeon_dig_connector;
1849                         drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
1850                         drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
1851                         if (i2c_bus->valid) {
1852                                 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1853                                 if (!radeon_connector->ddc_bus)
1854                                         DRM_ERROR("HDMI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1855                         }
1856                         drm_object_attach_property(&radeon_connector->base.base,
1857                                                       rdev->mode_info.coherent_mode_property,
1858                                                       1);
1859                         if (ASIC_IS_AVIVO(rdev)) {
1860                                 drm_object_attach_property(&radeon_connector->base.base,
1861                                                               rdev->mode_info.underscan_property,
1862                                                               UNDERSCAN_OFF);
1863                                 drm_object_attach_property(&radeon_connector->base.base,
1864                                                               rdev->mode_info.underscan_hborder_property,
1865                                                               0);
1866                                 drm_object_attach_property(&radeon_connector->base.base,
1867                                                               rdev->mode_info.underscan_vborder_property,
1868                                                               0);
1869                         }
1870                         if (ASIC_IS_DCE2(rdev) && (radeon_audio != 0)) {
1871                                 drm_object_attach_property(&radeon_connector->base.base,
1872                                                            rdev->mode_info.audio_property,
1873                                                            RADEON_AUDIO_AUTO);
1874                         }
1875                         if (ASIC_IS_AVIVO(rdev)) {
1876                                 drm_object_attach_property(&radeon_connector->base.base,
1877                                                            rdev->mode_info.dither_property,
1878                                                            RADEON_FMT_DITHER_DISABLE);
1879                         }
1880                         subpixel_order = SubPixelHorizontalRGB;
1881                         connector->interlace_allowed = true;
1882                         if (connector_type == DRM_MODE_CONNECTOR_HDMIB)
1883                                 connector->doublescan_allowed = true;
1884                         else
1885                                 connector->doublescan_allowed = false;
1886                         break;
1887                 case DRM_MODE_CONNECTOR_DisplayPort:
1888                         radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
1889                         if (!radeon_dig_connector)
1890                                 goto failed;
1891                         radeon_dig_connector->igp_lane_info = igp_lane_info;
1892                         radeon_connector->con_priv = radeon_dig_connector;
1893                         drm_connector_init(dev, &radeon_connector->base, &radeon_dp_connector_funcs, connector_type);
1894                         drm_connector_helper_add(&radeon_connector->base, &radeon_dp_connector_helper_funcs);
1895                         if (i2c_bus->valid) {
1896                                 /* add DP i2c bus */
1897                                 radeon_dig_connector->dp_i2c_bus = radeon_i2c_create_dp(dev, i2c_bus, "DP-auxch");
1898                                 if (!radeon_dig_connector->dp_i2c_bus)
1899                                         DRM_ERROR("DP: Failed to assign dp ddc bus! Check dmesg for i2c errors.\n");
1900                                 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1901                                 if (radeon_connector->ddc_bus)
1902                                         has_aux = true;
1903                                 else
1904                                         DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1905                         }
1906                         subpixel_order = SubPixelHorizontalRGB;
1907                         drm_object_attach_property(&radeon_connector->base.base,
1908                                                       rdev->mode_info.coherent_mode_property,
1909                                                       1);
1910                         if (ASIC_IS_AVIVO(rdev)) {
1911                                 drm_object_attach_property(&radeon_connector->base.base,
1912                                                               rdev->mode_info.underscan_property,
1913                                                               UNDERSCAN_OFF);
1914                                 drm_object_attach_property(&radeon_connector->base.base,
1915                                                               rdev->mode_info.underscan_hborder_property,
1916                                                               0);
1917                                 drm_object_attach_property(&radeon_connector->base.base,
1918                                                               rdev->mode_info.underscan_vborder_property,
1919                                                               0);
1920                         }
1921                         if (ASIC_IS_DCE2(rdev) && (radeon_audio != 0)) {
1922                                 drm_object_attach_property(&radeon_connector->base.base,
1923                                                            rdev->mode_info.audio_property,
1924                                                            RADEON_AUDIO_AUTO);
1925                         }
1926                         if (ASIC_IS_AVIVO(rdev)) {
1927                                 drm_object_attach_property(&radeon_connector->base.base,
1928                                                            rdev->mode_info.dither_property,
1929                                                            RADEON_FMT_DITHER_DISABLE);
1930
1931                         }
1932                         connector->interlace_allowed = true;
1933                         /* in theory with a DP to VGA converter... */
1934                         connector->doublescan_allowed = false;
1935                         break;
1936                 case DRM_MODE_CONNECTOR_eDP:
1937                         radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
1938                         if (!radeon_dig_connector)
1939                                 goto failed;
1940                         radeon_dig_connector->igp_lane_info = igp_lane_info;
1941                         radeon_connector->con_priv = radeon_dig_connector;
1942                         drm_connector_init(dev, &radeon_connector->base, &radeon_edp_connector_funcs, connector_type);
1943                         drm_connector_helper_add(&radeon_connector->base, &radeon_dp_connector_helper_funcs);
1944                         if (i2c_bus->valid) {
1945                                 /* add DP i2c bus */
1946                                 radeon_dig_connector->dp_i2c_bus = radeon_i2c_create_dp(dev, i2c_bus, "eDP-auxch");
1947                                 if (radeon_dig_connector->dp_i2c_bus)
1948                                         has_aux = true;
1949                                 else
1950                                         DRM_ERROR("DP: Failed to assign dp ddc bus! Check dmesg for i2c errors.\n");
1951                                 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1952                                 if (!radeon_connector->ddc_bus)
1953                                         DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1954                         }
1955                         drm_object_attach_property(&radeon_connector->base.base,
1956                                                       dev->mode_config.scaling_mode_property,
1957                                                       DRM_MODE_SCALE_FULLSCREEN);
1958                         subpixel_order = SubPixelHorizontalRGB;
1959                         connector->interlace_allowed = false;
1960                         connector->doublescan_allowed = false;
1961                         break;
1962                 case DRM_MODE_CONNECTOR_SVIDEO:
1963                 case DRM_MODE_CONNECTOR_Composite:
1964                 case DRM_MODE_CONNECTOR_9PinDIN:
1965                         drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
1966                         drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
1967                         radeon_connector->dac_load_detect = true;
1968                         drm_object_attach_property(&radeon_connector->base.base,
1969                                                       rdev->mode_info.load_detect_property,
1970                                                       1);
1971                         drm_object_attach_property(&radeon_connector->base.base,
1972                                                       rdev->mode_info.tv_std_property,
1973                                                       radeon_atombios_get_tv_info(rdev));
1974                         /* no HPD on analog connectors */
1975                         radeon_connector->hpd.hpd = RADEON_HPD_NONE;
1976                         connector->interlace_allowed = false;
1977                         connector->doublescan_allowed = false;
1978                         break;
1979                 case DRM_MODE_CONNECTOR_LVDS:
1980                         radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
1981                         if (!radeon_dig_connector)
1982                                 goto failed;
1983                         radeon_dig_connector->igp_lane_info = igp_lane_info;
1984                         radeon_connector->con_priv = radeon_dig_connector;
1985                         drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
1986                         drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
1987                         if (i2c_bus->valid) {
1988                                 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1989                                 if (!radeon_connector->ddc_bus)
1990                                         DRM_ERROR("LVDS: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1991                         }
1992                         drm_object_attach_property(&radeon_connector->base.base,
1993                                                       dev->mode_config.scaling_mode_property,
1994                                                       DRM_MODE_SCALE_FULLSCREEN);
1995                         subpixel_order = SubPixelHorizontalRGB;
1996                         connector->interlace_allowed = false;
1997                         connector->doublescan_allowed = false;
1998                         break;
1999                 }
2000         }
2001
2002         if (radeon_connector->hpd.hpd == RADEON_HPD_NONE) {
2003                 if (i2c_bus->valid)
2004                         connector->polled = DRM_CONNECTOR_POLL_CONNECT;
2005         } else
2006                 connector->polled = DRM_CONNECTOR_POLL_HPD;
2007
2008         connector->display_info.subpixel_order = subpixel_order;
2009         drm_sysfs_connector_add(connector);
2010
2011         if (has_aux)
2012                 radeon_dp_aux_init(radeon_connector);
2013
2014         return;
2015
2016 failed:
2017         drm_connector_cleanup(connector);
2018         kfree(connector);
2019 }
2020
2021 void
2022 radeon_add_legacy_connector(struct drm_device *dev,
2023                             uint32_t connector_id,
2024                             uint32_t supported_device,
2025                             int connector_type,
2026                             struct radeon_i2c_bus_rec *i2c_bus,
2027                             uint16_t connector_object_id,
2028                             struct radeon_hpd *hpd)
2029 {
2030         struct radeon_device *rdev = dev->dev_private;
2031         struct drm_connector *connector;
2032         struct radeon_connector *radeon_connector;
2033         uint32_t subpixel_order = SubPixelNone;
2034
2035         if (connector_type == DRM_MODE_CONNECTOR_Unknown)
2036                 return;
2037
2038         /* if the user selected tv=0 don't try and add the connector */
2039         if (((connector_type == DRM_MODE_CONNECTOR_SVIDEO) ||
2040              (connector_type == DRM_MODE_CONNECTOR_Composite) ||
2041              (connector_type == DRM_MODE_CONNECTOR_9PinDIN)) &&
2042             (radeon_tv == 0))
2043                 return;
2044
2045         /* see if we already added it */
2046         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
2047                 radeon_connector = to_radeon_connector(connector);
2048                 if (radeon_connector->connector_id == connector_id) {
2049                         radeon_connector->devices |= supported_device;
2050                         return;
2051                 }
2052         }
2053
2054         radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
2055         if (!radeon_connector)
2056                 return;
2057
2058         connector = &radeon_connector->base;
2059
2060         radeon_connector->connector_id = connector_id;
2061         radeon_connector->devices = supported_device;
2062         radeon_connector->connector_object_id = connector_object_id;
2063         radeon_connector->hpd = *hpd;
2064
2065         switch (connector_type) {
2066         case DRM_MODE_CONNECTOR_VGA:
2067                 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
2068                 drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
2069                 if (i2c_bus->valid) {
2070                         radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2071                         if (!radeon_connector->ddc_bus)
2072                                 DRM_ERROR("VGA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2073                 }
2074                 radeon_connector->dac_load_detect = true;
2075                 drm_object_attach_property(&radeon_connector->base.base,
2076                                               rdev->mode_info.load_detect_property,
2077                                               1);
2078                 /* no HPD on analog connectors */
2079                 radeon_connector->hpd.hpd = RADEON_HPD_NONE;
2080                 connector->polled = DRM_CONNECTOR_POLL_CONNECT;
2081                 connector->interlace_allowed = true;
2082                 connector->doublescan_allowed = true;
2083                 break;
2084         case DRM_MODE_CONNECTOR_DVIA:
2085                 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
2086                 drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
2087                 if (i2c_bus->valid) {
2088                         radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2089                         if (!radeon_connector->ddc_bus)
2090                                 DRM_ERROR("DVIA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2091                 }
2092                 radeon_connector->dac_load_detect = true;
2093                 drm_object_attach_property(&radeon_connector->base.base,
2094                                               rdev->mode_info.load_detect_property,
2095                                               1);
2096                 /* no HPD on analog connectors */
2097                 radeon_connector->hpd.hpd = RADEON_HPD_NONE;
2098                 connector->interlace_allowed = true;
2099                 connector->doublescan_allowed = true;
2100                 break;
2101         case DRM_MODE_CONNECTOR_DVII:
2102         case DRM_MODE_CONNECTOR_DVID:
2103                 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
2104                 drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
2105                 if (i2c_bus->valid) {
2106                         radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2107                         if (!radeon_connector->ddc_bus)
2108                                 DRM_ERROR("DVI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2109                 }
2110                 if (connector_type == DRM_MODE_CONNECTOR_DVII) {
2111                         radeon_connector->dac_load_detect = true;
2112                         drm_object_attach_property(&radeon_connector->base.base,
2113                                                       rdev->mode_info.load_detect_property,
2114                                                       1);
2115                 }
2116                 subpixel_order = SubPixelHorizontalRGB;
2117                 connector->interlace_allowed = true;
2118                 if (connector_type == DRM_MODE_CONNECTOR_DVII)
2119                         connector->doublescan_allowed = true;
2120                 else
2121                         connector->doublescan_allowed = false;
2122                 break;
2123         case DRM_MODE_CONNECTOR_SVIDEO:
2124         case DRM_MODE_CONNECTOR_Composite:
2125         case DRM_MODE_CONNECTOR_9PinDIN:
2126                 drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
2127                 drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
2128                 radeon_connector->dac_load_detect = true;
2129                 /* RS400,RC410,RS480 chipset seems to report a lot
2130                  * of false positive on load detect, we haven't yet
2131                  * found a way to make load detect reliable on those
2132                  * chipset, thus just disable it for TV.
2133                  */
2134                 if (rdev->family == CHIP_RS400 || rdev->family == CHIP_RS480)
2135                         radeon_connector->dac_load_detect = false;
2136                 drm_object_attach_property(&radeon_connector->base.base,
2137                                               rdev->mode_info.load_detect_property,
2138                                               radeon_connector->dac_load_detect);
2139                 drm_object_attach_property(&radeon_connector->base.base,
2140                                               rdev->mode_info.tv_std_property,
2141                                               radeon_combios_get_tv_info(rdev));
2142                 /* no HPD on analog connectors */
2143                 radeon_connector->hpd.hpd = RADEON_HPD_NONE;
2144                 connector->interlace_allowed = false;
2145                 connector->doublescan_allowed = false;
2146                 break;
2147         case DRM_MODE_CONNECTOR_LVDS:
2148                 drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
2149                 drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
2150                 if (i2c_bus->valid) {
2151                         radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2152                         if (!radeon_connector->ddc_bus)
2153                                 DRM_ERROR("LVDS: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2154                 }
2155                 drm_object_attach_property(&radeon_connector->base.base,
2156                                               dev->mode_config.scaling_mode_property,
2157                                               DRM_MODE_SCALE_FULLSCREEN);
2158                 subpixel_order = SubPixelHorizontalRGB;
2159                 connector->interlace_allowed = false;
2160                 connector->doublescan_allowed = false;
2161                 break;
2162         }
2163
2164         if (radeon_connector->hpd.hpd == RADEON_HPD_NONE) {
2165                 if (i2c_bus->valid)
2166                         connector->polled = DRM_CONNECTOR_POLL_CONNECT;
2167         } else
2168                 connector->polled = DRM_CONNECTOR_POLL_HPD;
2169         connector->display_info.subpixel_order = subpixel_order;
2170         drm_sysfs_connector_add(connector);
2171 }