drivers/gpu/drm/radeon/radeon_connectors.c

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