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