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