drivers/gpu/drm/radeon/radeon_connectors.c

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