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