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 static enum drm_connector_status
1072 radeon_dp_detect(struct drm_connector *connector, bool force)
1073 {
1074         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1075         enum drm_connector_status ret = connector_status_disconnected;
1076         struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
1077
1078         if (radeon_connector->edid) {
1079                 kfree(radeon_connector->edid);
1080                 radeon_connector->edid = NULL;
1081         }
1082
1083         if (connector->connector_type == DRM_MODE_CONNECTOR_eDP) {
1084                 /* eDP is always DP */
1085                 radeon_dig_connector->dp_sink_type = CONNECTOR_OBJECT_ID_DISPLAYPORT;
1086                 if (!radeon_dig_connector->edp_on)
1087                         atombios_set_edp_panel_power(connector,
1088                                                      ATOM_TRANSMITTER_ACTION_POWER_ON);
1089                 if (radeon_dp_getdpcd(radeon_connector))
1090                         ret = connector_status_connected;
1091                 if (!radeon_dig_connector->edp_on)
1092                         atombios_set_edp_panel_power(connector,
1093                                                      ATOM_TRANSMITTER_ACTION_POWER_OFF);
1094         } else {
1095                 radeon_dig_connector->dp_sink_type = radeon_dp_getsinktype(radeon_connector);
1096                 if (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) {
1097                         if (radeon_dp_getdpcd(radeon_connector))
1098                                 ret = connector_status_connected;
1099                 } else {
1100                         if (radeon_ddc_probe(radeon_connector))
1101                                 ret = connector_status_connected;
1102                 }
1103         }
1104
1105         radeon_connector_update_scratch_regs(connector, ret);
1106         return ret;
1107 }
1108
1109 static int radeon_dp_mode_valid(struct drm_connector *connector,
1110                                   struct drm_display_mode *mode)
1111 {
1112         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1113         struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
1114
1115         /* XXX check mode bandwidth */
1116
1117         if ((radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) ||
1118             (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_eDP))
1119                 return radeon_dp_mode_valid_helper(radeon_connector, mode);
1120         else
1121                 return MODE_OK;
1122 }
1123
1124 struct drm_connector_helper_funcs radeon_dp_connector_helper_funcs = {
1125         .get_modes = radeon_dp_get_modes,
1126         .mode_valid = radeon_dp_mode_valid,
1127         .best_encoder = radeon_dvi_encoder,
1128 };
1129
1130 struct drm_connector_funcs radeon_dp_connector_funcs = {
1131         .dpms = drm_helper_connector_dpms,
1132         .detect = radeon_dp_detect,
1133         .fill_modes = drm_helper_probe_single_connector_modes,
1134         .set_property = radeon_connector_set_property,
1135         .destroy = radeon_dp_connector_destroy,
1136         .force = radeon_dvi_force,
1137 };
1138
1139 void
1140 radeon_add_atom_connector(struct drm_device *dev,
1141                           uint32_t connector_id,
1142                           uint32_t supported_device,
1143                           int connector_type,
1144                           struct radeon_i2c_bus_rec *i2c_bus,
1145                           uint32_t igp_lane_info,
1146                           uint16_t connector_object_id,
1147                           struct radeon_hpd *hpd,
1148                           struct radeon_router *router)
1149 {
1150         struct radeon_device *rdev = dev->dev_private;
1151         struct drm_connector *connector;
1152         struct radeon_connector *radeon_connector;
1153         struct radeon_connector_atom_dig *radeon_dig_connector;
1154         uint32_t subpixel_order = SubPixelNone;
1155         bool shared_ddc = false;
1156
1157         if (connector_type == DRM_MODE_CONNECTOR_Unknown)
1158                 return;
1159
1160         /* if the user selected tv=0 don't try and add the connector */
1161         if (((connector_type == DRM_MODE_CONNECTOR_SVIDEO) ||
1162              (connector_type == DRM_MODE_CONNECTOR_Composite) ||
1163              (connector_type == DRM_MODE_CONNECTOR_9PinDIN)) &&
1164             (radeon_tv == 0))
1165                 return;
1166
1167         /* see if we already added it */
1168         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
1169                 radeon_connector = to_radeon_connector(connector);
1170                 if (radeon_connector->connector_id == connector_id) {
1171                         radeon_connector->devices |= supported_device;
1172                         return;
1173                 }
1174                 if (radeon_connector->ddc_bus && i2c_bus->valid) {
1175                         if (radeon_connector->ddc_bus->rec.i2c_id == i2c_bus->i2c_id) {
1176                                 radeon_connector->shared_ddc = true;
1177                                 shared_ddc = true;
1178                         }
1179                         if (radeon_connector->router_bus && router->ddc_valid &&
1180                             (radeon_connector->router.router_id == router->router_id)) {
1181                                 radeon_connector->shared_ddc = false;
1182                                 shared_ddc = false;
1183                         }
1184                 }
1185         }
1186
1187         radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
1188         if (!radeon_connector)
1189                 return;
1190
1191         connector = &radeon_connector->base;
1192
1193         radeon_connector->connector_id = connector_id;
1194         radeon_connector->devices = supported_device;
1195         radeon_connector->shared_ddc = shared_ddc;
1196         radeon_connector->connector_object_id = connector_object_id;
1197         radeon_connector->hpd = *hpd;
1198         radeon_connector->router = *router;
1199         if (router->ddc_valid || router->cd_valid) {
1200                 radeon_connector->router_bus = radeon_i2c_lookup(rdev, &router->i2c_info);
1201                 if (!radeon_connector->router_bus)
1202                         goto failed;
1203         }
1204         switch (connector_type) {
1205         case DRM_MODE_CONNECTOR_VGA:
1206                 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1207                 drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1208                 if (i2c_bus->valid) {
1209                         radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1210                         if (!radeon_connector->ddc_bus)
1211                                 goto failed;
1212                 }
1213                 radeon_connector->dac_load_detect = true;
1214                 drm_connector_attach_property(&radeon_connector->base,
1215                                               rdev->mode_info.load_detect_property,
1216                                               1);
1217                 /* no HPD on analog connectors */
1218                 radeon_connector->hpd.hpd = RADEON_HPD_NONE;
1219                 connector->polled = DRM_CONNECTOR_POLL_CONNECT;
1220                 connector->interlace_allowed = true;
1221                 connector->doublescan_allowed = true;
1222                 break;
1223         case DRM_MODE_CONNECTOR_DVIA:
1224                 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1225                 drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1226                 if (i2c_bus->valid) {
1227                         radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1228                         if (!radeon_connector->ddc_bus)
1229                                 goto failed;
1230                 }
1231                 radeon_connector->dac_load_detect = true;
1232                 drm_connector_attach_property(&radeon_connector->base,
1233                                               rdev->mode_info.load_detect_property,
1234                                               1);
1235                 /* no HPD on analog connectors */
1236                 radeon_connector->hpd.hpd = RADEON_HPD_NONE;
1237                 connector->interlace_allowed = true;
1238                 connector->doublescan_allowed = true;
1239                 break;
1240         case DRM_MODE_CONNECTOR_DVII:
1241         case DRM_MODE_CONNECTOR_DVID:
1242                 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
1243                 if (!radeon_dig_connector)
1244                         goto failed;
1245                 radeon_dig_connector->igp_lane_info = igp_lane_info;
1246                 radeon_connector->con_priv = radeon_dig_connector;
1247                 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
1248                 drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
1249                 if (i2c_bus->valid) {
1250                         radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1251                         if (!radeon_connector->ddc_bus)
1252                                 goto failed;
1253                 }
1254                 subpixel_order = SubPixelHorizontalRGB;
1255                 drm_connector_attach_property(&radeon_connector->base,
1256                                               rdev->mode_info.coherent_mode_property,
1257                                               1);
1258                 if (ASIC_IS_AVIVO(rdev)) {
1259                         drm_connector_attach_property(&radeon_connector->base,
1260                                                       rdev->mode_info.underscan_property,
1261                                                       UNDERSCAN_OFF);
1262                         drm_connector_attach_property(&radeon_connector->base,
1263                                                       rdev->mode_info.underscan_hborder_property,
1264                                                       0);
1265                         drm_connector_attach_property(&radeon_connector->base,
1266                                                       rdev->mode_info.underscan_vborder_property,
1267                                                       0);
1268                 }
1269                 if (connector_type == DRM_MODE_CONNECTOR_DVII) {
1270                         radeon_connector->dac_load_detect = true;
1271                         drm_connector_attach_property(&radeon_connector->base,
1272                                                       rdev->mode_info.load_detect_property,
1273                                                       1);
1274                 }
1275                 connector->interlace_allowed = true;
1276                 if (connector_type == DRM_MODE_CONNECTOR_DVII)
1277                         connector->doublescan_allowed = true;
1278                 else
1279                         connector->doublescan_allowed = false;
1280                 break;
1281         case DRM_MODE_CONNECTOR_HDMIA:
1282         case DRM_MODE_CONNECTOR_HDMIB:
1283                 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
1284                 if (!radeon_dig_connector)
1285                         goto failed;
1286                 radeon_dig_connector->igp_lane_info = igp_lane_info;
1287                 radeon_connector->con_priv = radeon_dig_connector;
1288                 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
1289                 drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
1290                 if (i2c_bus->valid) {
1291                         radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1292                         if (!radeon_connector->ddc_bus)
1293                                 goto failed;
1294                 }
1295                 drm_connector_attach_property(&radeon_connector->base,
1296                                               rdev->mode_info.coherent_mode_property,
1297                                               1);
1298                 if (ASIC_IS_AVIVO(rdev)) {
1299                         drm_connector_attach_property(&radeon_connector->base,
1300                                                       rdev->mode_info.underscan_property,
1301                                                       UNDERSCAN_OFF);
1302                         drm_connector_attach_property(&radeon_connector->base,
1303                                                       rdev->mode_info.underscan_hborder_property,
1304                                                       0);
1305                         drm_connector_attach_property(&radeon_connector->base,
1306                                                       rdev->mode_info.underscan_vborder_property,
1307                                                       0);
1308                 }
1309                 subpixel_order = SubPixelHorizontalRGB;
1310                 connector->interlace_allowed = true;
1311                 if (connector_type == DRM_MODE_CONNECTOR_HDMIB)
1312                         connector->doublescan_allowed = true;
1313                 else
1314                         connector->doublescan_allowed = false;
1315                 break;
1316         case DRM_MODE_CONNECTOR_DisplayPort:
1317         case DRM_MODE_CONNECTOR_eDP:
1318                 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
1319                 if (!radeon_dig_connector)
1320                         goto failed;
1321                 radeon_dig_connector->igp_lane_info = igp_lane_info;
1322                 radeon_connector->con_priv = radeon_dig_connector;
1323                 drm_connector_init(dev, &radeon_connector->base, &radeon_dp_connector_funcs, connector_type);
1324                 drm_connector_helper_add(&radeon_connector->base, &radeon_dp_connector_helper_funcs);
1325                 if (i2c_bus->valid) {
1326                         /* add DP i2c bus */
1327                         if (connector_type == DRM_MODE_CONNECTOR_eDP)
1328                                 radeon_dig_connector->dp_i2c_bus = radeon_i2c_create_dp(dev, i2c_bus, "eDP-auxch");
1329                         else
1330                                 radeon_dig_connector->dp_i2c_bus = radeon_i2c_create_dp(dev, i2c_bus, "DP-auxch");
1331                         if (!radeon_dig_connector->dp_i2c_bus)
1332                                 goto failed;
1333                         radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1334                         if (!radeon_connector->ddc_bus)
1335                                 goto failed;
1336                 }
1337                 subpixel_order = SubPixelHorizontalRGB;
1338                 drm_connector_attach_property(&radeon_connector->base,
1339                                               rdev->mode_info.coherent_mode_property,
1340                                               1);
1341                 if (ASIC_IS_AVIVO(rdev)) {
1342                         drm_connector_attach_property(&radeon_connector->base,
1343                                                       rdev->mode_info.underscan_property,
1344                                                       UNDERSCAN_OFF);
1345                         drm_connector_attach_property(&radeon_connector->base,
1346                                                       rdev->mode_info.underscan_hborder_property,
1347                                                       0);
1348                         drm_connector_attach_property(&radeon_connector->base,
1349                                                       rdev->mode_info.underscan_vborder_property,
1350                                                       0);
1351                 }
1352                 connector->interlace_allowed = true;
1353                 /* in theory with a DP to VGA converter... */
1354                 connector->doublescan_allowed = false;
1355                 break;
1356         case DRM_MODE_CONNECTOR_SVIDEO:
1357         case DRM_MODE_CONNECTOR_Composite:
1358         case DRM_MODE_CONNECTOR_9PinDIN:
1359                 drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
1360                 drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
1361                 radeon_connector->dac_load_detect = true;
1362                 drm_connector_attach_property(&radeon_connector->base,
1363                                               rdev->mode_info.load_detect_property,
1364                                               1);
1365                 drm_connector_attach_property(&radeon_connector->base,
1366                                               rdev->mode_info.tv_std_property,
1367                                               radeon_atombios_get_tv_info(rdev));
1368                 /* no HPD on analog connectors */
1369                 radeon_connector->hpd.hpd = RADEON_HPD_NONE;
1370                 connector->interlace_allowed = false;
1371                 connector->doublescan_allowed = false;
1372                 break;
1373         case DRM_MODE_CONNECTOR_LVDS:
1374                 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
1375                 if (!radeon_dig_connector)
1376                         goto failed;
1377                 radeon_dig_connector->igp_lane_info = igp_lane_info;
1378                 radeon_connector->con_priv = radeon_dig_connector;
1379                 drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
1380                 drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
1381                 if (i2c_bus->valid) {
1382                         radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1383                         if (!radeon_connector->ddc_bus)
1384                                 goto failed;
1385                 }
1386                 drm_connector_attach_property(&radeon_connector->base,
1387                                               dev->mode_config.scaling_mode_property,
1388                                               DRM_MODE_SCALE_FULLSCREEN);
1389                 subpixel_order = SubPixelHorizontalRGB;
1390                 connector->interlace_allowed = false;
1391                 connector->doublescan_allowed = false;
1392                 break;
1393         }
1394
1395         if (radeon_connector->hpd.hpd == RADEON_HPD_NONE) {
1396                 if (i2c_bus->valid)
1397                         connector->polled = DRM_CONNECTOR_POLL_CONNECT;
1398         } else
1399                 connector->polled = DRM_CONNECTOR_POLL_HPD;
1400
1401         connector->display_info.subpixel_order = subpixel_order;
1402         drm_sysfs_connector_add(connector);
1403         return;
1404
1405 failed:
1406         drm_connector_cleanup(connector);
1407         kfree(connector);
1408 }
1409
1410 void
1411 radeon_add_legacy_connector(struct drm_device *dev,
1412                             uint32_t connector_id,
1413                             uint32_t supported_device,
1414                             int connector_type,
1415                             struct radeon_i2c_bus_rec *i2c_bus,
1416                             uint16_t connector_object_id,
1417                             struct radeon_hpd *hpd)
1418 {
1419         struct radeon_device *rdev = dev->dev_private;
1420         struct drm_connector *connector;
1421         struct radeon_connector *radeon_connector;
1422         uint32_t subpixel_order = SubPixelNone;
1423
1424         if (connector_type == DRM_MODE_CONNECTOR_Unknown)
1425                 return;
1426
1427         /* if the user selected tv=0 don't try and add the connector */
1428         if (((connector_type == DRM_MODE_CONNECTOR_SVIDEO) ||
1429              (connector_type == DRM_MODE_CONNECTOR_Composite) ||
1430              (connector_type == DRM_MODE_CONNECTOR_9PinDIN)) &&
1431             (radeon_tv == 0))
1432                 return;
1433
1434         /* see if we already added it */
1435         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
1436                 radeon_connector = to_radeon_connector(connector);
1437                 if (radeon_connector->connector_id == connector_id) {
1438                         radeon_connector->devices |= supported_device;
1439                         return;
1440                 }
1441         }
1442
1443         radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
1444         if (!radeon_connector)
1445                 return;
1446
1447         connector = &radeon_connector->base;
1448
1449         radeon_connector->connector_id = connector_id;
1450         radeon_connector->devices = supported_device;
1451         radeon_connector->connector_object_id = connector_object_id;
1452         radeon_connector->hpd = *hpd;
1453         switch (connector_type) {
1454         case DRM_MODE_CONNECTOR_VGA:
1455                 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1456                 drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1457                 if (i2c_bus->valid) {
1458                         radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1459                         if (!radeon_connector->ddc_bus)
1460                                 goto failed;
1461                 }
1462                 radeon_connector->dac_load_detect = true;
1463                 drm_connector_attach_property(&radeon_connector->base,
1464                                               rdev->mode_info.load_detect_property,
1465                                               1);
1466                 /* no HPD on analog connectors */
1467                 radeon_connector->hpd.hpd = RADEON_HPD_NONE;
1468                 connector->polled = DRM_CONNECTOR_POLL_CONNECT;
1469                 connector->interlace_allowed = true;
1470                 connector->doublescan_allowed = true;
1471                 break;
1472         case DRM_MODE_CONNECTOR_DVIA:
1473                 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1474                 drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1475                 if (i2c_bus->valid) {
1476                         radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1477                         if (!radeon_connector->ddc_bus)
1478                                 goto failed;
1479                 }
1480                 radeon_connector->dac_load_detect = true;
1481                 drm_connector_attach_property(&radeon_connector->base,
1482                                               rdev->mode_info.load_detect_property,
1483                                               1);
1484                 /* no HPD on analog connectors */
1485                 radeon_connector->hpd.hpd = RADEON_HPD_NONE;
1486                 connector->interlace_allowed = true;
1487                 connector->doublescan_allowed = true;
1488                 break;
1489         case DRM_MODE_CONNECTOR_DVII:
1490         case DRM_MODE_CONNECTOR_DVID:
1491                 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
1492                 drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
1493                 if (i2c_bus->valid) {
1494                         radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1495                         if (!radeon_connector->ddc_bus)
1496                                 goto failed;
1497                 }
1498                 if (connector_type == DRM_MODE_CONNECTOR_DVII) {
1499                         radeon_connector->dac_load_detect = true;
1500                         drm_connector_attach_property(&radeon_connector->base,
1501                                                       rdev->mode_info.load_detect_property,
1502                                                       1);
1503                 }
1504                 subpixel_order = SubPixelHorizontalRGB;
1505                 connector->interlace_allowed = true;
1506                 if (connector_type == DRM_MODE_CONNECTOR_DVII)
1507                         connector->doublescan_allowed = true;
1508                 else
1509                         connector->doublescan_allowed = false;
1510                 break;
1511         case DRM_MODE_CONNECTOR_SVIDEO:
1512         case DRM_MODE_CONNECTOR_Composite:
1513         case DRM_MODE_CONNECTOR_9PinDIN:
1514                 drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
1515                 drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
1516                 radeon_connector->dac_load_detect = true;
1517                 /* RS400,RC410,RS480 chipset seems to report a lot
1518                  * of false positive on load detect, we haven't yet
1519                  * found a way to make load detect reliable on those
1520                  * chipset, thus just disable it for TV.
1521                  */
1522                 if (rdev->family == CHIP_RS400 || rdev->family == CHIP_RS480)
1523                         radeon_connector->dac_load_detect = false;
1524                 drm_connector_attach_property(&radeon_connector->base,
1525                                               rdev->mode_info.load_detect_property,
1526                                               radeon_connector->dac_load_detect);
1527                 drm_connector_attach_property(&radeon_connector->base,
1528                                               rdev->mode_info.tv_std_property,
1529                                               radeon_combios_get_tv_info(rdev));
1530                 /* no HPD on analog connectors */
1531                 radeon_connector->hpd.hpd = RADEON_HPD_NONE;
1532                 connector->interlace_allowed = false;
1533                 connector->doublescan_allowed = false;
1534                 break;
1535         case DRM_MODE_CONNECTOR_LVDS:
1536                 drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
1537                 drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
1538                 if (i2c_bus->valid) {
1539                         radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1540                         if (!radeon_connector->ddc_bus)
1541                                 goto failed;
1542                 }
1543                 drm_connector_attach_property(&radeon_connector->base,
1544                                               dev->mode_config.scaling_mode_property,
1545                                               DRM_MODE_SCALE_FULLSCREEN);
1546                 subpixel_order = SubPixelHorizontalRGB;
1547                 connector->interlace_allowed = false;
1548                 connector->doublescan_allowed = false;
1549                 break;
1550         }
1551
1552         if (radeon_connector->hpd.hpd == RADEON_HPD_NONE) {
1553                 if (i2c_bus->valid)
1554                         connector->polled = DRM_CONNECTOR_POLL_CONNECT;
1555         } else
1556                 connector->polled = DRM_CONNECTOR_POLL_HPD;
1557         connector->display_info.subpixel_order = subpixel_order;
1558         drm_sysfs_connector_add(connector);
1559         if (connector_type == DRM_MODE_CONNECTOR_LVDS) {
1560                 struct drm_encoder *drm_encoder;
1561
1562                 list_for_each_entry(drm_encoder, &dev->mode_config.encoder_list, head) {
1563                         struct radeon_encoder *radeon_encoder;
1564
1565                         radeon_encoder = to_radeon_encoder(drm_encoder);
1566                         if (radeon_encoder->encoder_id == ENCODER_OBJECT_ID_INTERNAL_LVDS)
1567                                 radeon_legacy_backlight_init(radeon_encoder, connector);
1568                 }
1569         }
1570         return;
1571
1572 failed:
1573         drm_connector_cleanup(connector);
1574         kfree(connector);
1575 }