sys/dev/drm/radeon/radeon_connectors.c

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