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