drivers/gpu/drm/radeon/radeon_connectors.c

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