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