drivers/gpu/drm/radeon/radeon_connectors.c

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