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