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