SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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 static void radeon_property_change_mode(struct drm_encoder *encoder)
  44 {
  45         struct drm_crtc *crtc = encoder->crtc;
  46
  47         if (crtc && crtc->enabled) {
  48                 drm_crtc_helper_set_mode(crtc, &crtc->mode,
  49                                          crtc->x, crtc->y, crtc->fb);
  50         }
  51 }
  52 static void
  53 radeon_connector_update_scratch_regs(struct drm_connector *connector, enum drm_connector_status status)
  54 {
  55         struct drm_device *dev = connector->dev;
  56         struct radeon_device *rdev = dev->dev_private;
  57         struct drm_encoder *best_encoder = NULL;
  58         struct drm_encoder *encoder = NULL;
  59         struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
  60         struct drm_mode_object *obj;
  61         bool connected;
  62         int i;
  63
  64         best_encoder = connector_funcs->best_encoder(connector);
  65
  66         for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
  67                 if (connector->encoder_ids[i] == 0)
  68                         break;
  69
  70                 obj = drm_mode_object_find(connector->dev,
  71                                            connector->encoder_ids[i],
  72                                            DRM_MODE_OBJECT_ENCODER);
  73                 if (!obj)
  74                         continue;
  75
  76                 encoder = obj_to_encoder(obj);
  77
  78                 if ((encoder == best_encoder) && (status == connector_status_connected))
  79                         connected = true;
  80                 else
  81                         connected = false;
  82
  83                 if (rdev->is_atom_bios)
  84                         radeon_atombios_connected_scratch_regs(connector, encoder, connected);
  85                 else
  86                         radeon_combios_connected_scratch_regs(connector, encoder, connected);
  87
  88         }
  89 }
  90
  91 struct drm_encoder *radeon_find_encoder(struct drm_connector *connector, int encoder_type)
  92 {
  93         struct drm_mode_object *obj;
  94         struct drm_encoder *encoder;
  95         int i;
  96
  97         for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
  98                 if (connector->encoder_ids[i] == 0)
  99                         break;
 100
 101                 obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER);
 102                 if (!obj)
 103                         continue;
 104
 105                 encoder = obj_to_encoder(obj);
 106                 if (encoder->encoder_type == encoder_type)
 107                         return encoder;
 108         }
 109         return NULL;
 110 }
 111
 112 struct drm_encoder *radeon_best_single_encoder(struct drm_connector *connector)
 113 {
 114         int enc_id = connector->encoder_ids[0];
 115         struct drm_mode_object *obj;
 116         struct drm_encoder *encoder;
 117
 118         /* pick the encoder ids */
 119         if (enc_id) {
 120                 obj = drm_mode_object_find(connector->dev, enc_id, DRM_MODE_OBJECT_ENCODER);
 121                 if (!obj)
 122                         return NULL;
 123                 encoder = obj_to_encoder(obj);
 124                 return encoder;
 125         }
 126         return NULL;
 127 }
 128
 129 /*
 130  * radeon_connector_analog_encoder_conflict_solve
 131  * - search for other connectors sharing this encoder
 132  *   if priority is true, then set them disconnected if this is connected
 133  *   if priority is false, set us disconnected if they are connected
 134  */
 135 static enum drm_connector_status
 136 radeon_connector_analog_encoder_conflict_solve(struct drm_connector *connector,
 137                                                struct drm_encoder *encoder,
 138                                                enum drm_connector_status current_status,
 139                                                bool priority)
 140 {
 141         struct drm_device *dev = connector->dev;
 142         struct drm_connector *conflict;
 143         int i;
 144
 145         list_for_each_entry(conflict, &dev->mode_config.connector_list, head) {
 146                 if (conflict == connector)
 147                         continue;
 148
 149                 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
 150                         if (conflict->encoder_ids[i] == 0)
 151                                 break;
 152
 153                         /* if the IDs match */
 154                         if (conflict->encoder_ids[i] == encoder->base.id) {
 155                                 if (conflict->status != connector_status_connected)
 156                                         continue;
 157
 158                                 if (priority == true) {
 159                                         DRM_INFO("1: conflicting encoders switching off %s\n", drm_get_connector_name(conflict));
 160                                         DRM_INFO("in favor of %s\n", drm_get_connector_name(connector));
 161                                         conflict->status = connector_status_disconnected;
 162                                         radeon_connector_update_scratch_regs(conflict, connector_status_disconnected);
 163                                 } else {
 164                                         DRM_INFO("2: conflicting encoders switching off %s\n", drm_get_connector_name(connector));
 165                                         DRM_INFO("in favor of %s\n", drm_get_connector_name(conflict));
 166                                         current_status = connector_status_disconnected;
 167                                 }
 168                                 break;
 169                         }
 170                 }
 171         }
 172         return current_status;
 173
 174 }
 175
 176 static struct drm_display_mode *radeon_fp_native_mode(struct drm_encoder *encoder)
 177 {
 178         struct drm_device *dev = encoder->dev;
 179         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
 180         struct drm_display_mode *mode = NULL;
 181         struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
 182
 183         if (native_mode->hdisplay != 0 &&
 184             native_mode->vdisplay != 0 &&
 185             native_mode->clock != 0) {
 186                 mode = drm_mode_duplicate(dev, native_mode);
 187                 mode->type = DRM_MODE_TYPE_PREFERRED | DRM_MODE_TYPE_DRIVER;
 188                 drm_mode_set_name(mode);
 189
 190                 DRM_DEBUG("Adding native panel mode %s\n", mode->name);
 191         }
 192         return mode;
 193 }
 194
 195 static void radeon_add_common_modes(struct drm_encoder *encoder, struct drm_connector *connector)
 196 {
 197         struct drm_device *dev = encoder->dev;
 198         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
 199         struct drm_display_mode *mode = NULL;
 200         struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
 201         int i;
 202         struct mode_size {
 203                 int w;
 204                 int h;
 205         } common_modes[17] = {
 206                 { 640,  480},
 207                 { 720,  480},
 208                 { 800,  600},
 209                 { 848,  480},
 210                 {1024,  768},
 211                 {1152,  768},
 212                 {1280,  720},
 213                 {1280,  800},
 214                 {1280,  854},
 215                 {1280,  960},
 216                 {1280, 1024},
 217                 {1440,  900},
 218                 {1400, 1050},
 219                 {1680, 1050},
 220                 {1600, 1200},
 221                 {1920, 1080},
 222                 {1920, 1200}
 223         };
 224
 225         for (i = 0; i < 17; i++) {
 226                 if (radeon_encoder->devices & (ATOM_DEVICE_TV_SUPPORT)) {
 227                         if (common_modes[i].w > 1024 ||
 228                             common_modes[i].h > 768)
 229                                 continue;
 230                 }
 231                 if (radeon_encoder->devices & (ATOM_DEVICE_LCD_SUPPORT)) {
 232                         if (common_modes[i].w > native_mode->hdisplay ||
 233                             common_modes[i].h > native_mode->vdisplay ||
 234                             (common_modes[i].w == native_mode->hdisplay &&
 235                              common_modes[i].h == native_mode->vdisplay))
 236                                 continue;
 237                 }
 238                 if (common_modes[i].w < 320 || common_modes[i].h < 200)
 239                         continue;
 240
 241                 mode = drm_cvt_mode(dev, common_modes[i].w, common_modes[i].h, 60, false, false, false);
 242                 drm_mode_probed_add(connector, mode);
 243         }
 244 }
 245
 246 int radeon_connector_set_property(struct drm_connector *connector, struct drm_property *property,
 247                                   uint64_t val)
 248 {
 249         struct drm_device *dev = connector->dev;
 250         struct radeon_device *rdev = dev->dev_private;
 251         struct drm_encoder *encoder;
 252         struct radeon_encoder *radeon_encoder;
 253
 254         if (property == rdev->mode_info.coherent_mode_property) {
 255                 struct radeon_encoder_atom_dig *dig;
 256
 257                 /* need to find digital encoder on connector */
 258                 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
 259                 if (!encoder)
 260                         return 0;
 261
 262                 radeon_encoder = to_radeon_encoder(encoder);
 263
 264                 if (!radeon_encoder->enc_priv)
 265                         return 0;
 266
 267                 dig = radeon_encoder->enc_priv;
 268                 dig->coherent_mode = val ? true : false;
 269                 radeon_property_change_mode(&radeon_encoder->base);
 270         }
 271
 272         if (property == rdev->mode_info.tv_std_property) {
 273                 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TVDAC);
 274                 if (!encoder) {
 275                         encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_DAC);
 276                 }
 277
 278                 if (!encoder)
 279                         return 0;
 280
 281                 radeon_encoder = to_radeon_encoder(encoder);
 282                 if (!radeon_encoder->enc_priv)
 283                         return 0;
 284                 if (rdev->is_atom_bios) {
 285                         struct radeon_encoder_atom_dac *dac_int;
 286                         dac_int = radeon_encoder->enc_priv;
 287                         dac_int->tv_std = val;
 288                 } else {
 289                         struct radeon_encoder_tv_dac *dac_int;
 290                         dac_int = radeon_encoder->enc_priv;
 291                         dac_int->tv_std = val;
 292                 }
 293                 radeon_property_change_mode(&radeon_encoder->base);
 294         }
 295
 296         if (property == rdev->mode_info.load_detect_property) {
 297                 struct radeon_connector *radeon_connector =
 298                         to_radeon_connector(connector);
 299
 300                 if (val == 0)
 301                         radeon_connector->dac_load_detect = false;
 302                 else
 303                         radeon_connector->dac_load_detect = true;
 304         }
 305
 306         if (property == rdev->mode_info.tmds_pll_property) {
 307                 struct radeon_encoder_int_tmds *tmds = NULL;
 308                 bool ret = false;
 309                 /* need to find digital encoder on connector */
 310                 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
 311                 if (!encoder)
 312                         return 0;
 313
 314                 radeon_encoder = to_radeon_encoder(encoder);
 315
 316                 tmds = radeon_encoder->enc_priv;
 317                 if (!tmds)
 318                         return 0;
 319
 320                 if (val == 0) {
 321                         if (rdev->is_atom_bios)
 322                                 ret = radeon_atombios_get_tmds_info(radeon_encoder, tmds);
 323                         else
 324                                 ret = radeon_legacy_get_tmds_info_from_combios(radeon_encoder, tmds);
 325                 }
 326                 if (val == 1 || ret == false) {
 327                         radeon_legacy_get_tmds_info_from_table(radeon_encoder, tmds);
 328                 }
 329                 radeon_property_change_mode(&radeon_encoder->base);
 330         }
 331
 332         return 0;
 333 }
 334
 335 static void radeon_fixup_lvds_native_mode(struct drm_encoder *encoder,
 336                                           struct drm_connector *connector)
 337 {
 338         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
 339         struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
 340
 341         /* Try to get native mode details from EDID if necessary */
 342         if (!native_mode->clock) {
 343                 struct drm_display_mode *t, *mode;
 344
 345                 list_for_each_entry_safe(mode, t, &connector->probed_modes, head) {
 346                         if (mode->hdisplay == native_mode->hdisplay &&
 347                             mode->vdisplay == native_mode->vdisplay) {
 348                                 *native_mode = *mode;
 349                                 drm_mode_set_crtcinfo(native_mode, CRTC_INTERLACE_HALVE_V);
 350                                 DRM_INFO("Determined LVDS native mode details from EDID\n");
 351                                 break;
 352                         }
 353                 }
 354         }
 355         if (!native_mode->clock) {
 356                 DRM_INFO("No LVDS native mode details, disabling RMX\n");
 357                 radeon_encoder->rmx_type = RMX_OFF;
 358         }
 359 }
 360
 361 static int radeon_lvds_get_modes(struct drm_connector *connector)
 362 {
 363         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 364         struct drm_encoder *encoder;
 365         int ret = 0;
 366         struct drm_display_mode *mode;
 367
 368         if (radeon_connector->ddc_bus) {
 369                 ret = radeon_ddc_get_modes(radeon_connector);
 370                 if (ret > 0) {
 371                         encoder = radeon_best_single_encoder(connector);
 372                         if (encoder) {
 373                                 radeon_fixup_lvds_native_mode(encoder, connector);
 374                                 /* add scaled modes */
 375                                 radeon_add_common_modes(encoder, connector);
 376                         }
 377                         return ret;
 378                 }
 379         }
 380
 381         encoder = radeon_best_single_encoder(connector);
 382         if (!encoder)
 383                 return 0;
 384
 385         /* we have no EDID modes */
 386         mode = radeon_fp_native_mode(encoder);
 387         if (mode) {
 388                 ret = 1;
 389                 drm_mode_probed_add(connector, mode);
 390                 /* add scaled modes */
 391                 radeon_add_common_modes(encoder, connector);
 392         }
 393
 394         return ret;
 395 }
 396
 397 static int radeon_lvds_mode_valid(struct drm_connector *connector,
 398                                   struct drm_display_mode *mode)
 399 {
 400         struct drm_encoder *encoder = radeon_best_single_encoder(connector);
 401
 402         if ((mode->hdisplay < 320) || (mode->vdisplay < 240))
 403                 return MODE_PANEL;
 404
 405         if (encoder) {
 406                 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
 407                 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
 408
 409                 /* AVIVO hardware supports downscaling modes larger than the panel
 410                  * to the panel size, but I'm not sure this is desirable.
 411                  */
 412                 if ((mode->hdisplay > native_mode->hdisplay) ||
 413                     (mode->vdisplay > native_mode->vdisplay))
 414                         return MODE_PANEL;
 415
 416                 /* if scaling is disabled, block non-native modes */
 417                 if (radeon_encoder->rmx_type == RMX_OFF) {
 418                         if ((mode->hdisplay != native_mode->hdisplay) ||
 419                             (mode->vdisplay != native_mode->vdisplay))
 420                                 return MODE_PANEL;
 421                 }
 422         }
 423
 424         return MODE_OK;
 425 }
 426
 427 static enum drm_connector_status radeon_lvds_detect(struct drm_connector *connector)
 428 {
 429         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 430         struct drm_encoder *encoder = radeon_best_single_encoder(connector);
 431         enum drm_connector_status ret = connector_status_disconnected;
 432
 433         if (encoder) {
 434                 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
 435                 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
 436
 437                 /* check if panel is valid */
 438                 if (native_mode->hdisplay >= 320 && native_mode->vdisplay >= 240)
 439                         ret = connector_status_connected;
 440
 441         }
 442
 443         /* check for edid as well */
 444         if (radeon_connector->edid)
 445                 ret = connector_status_connected;
 446         else {
 447                 if (radeon_connector->ddc_bus) {
 448                         radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
 449                         radeon_connector->edid = drm_get_edid(&radeon_connector->base,
 450                                                               &radeon_connector->ddc_bus->adapter);
 451                         radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
 452                         if (radeon_connector->edid)
 453                                 ret = connector_status_connected;
 454                 }
 455         }
 456         /* check acpi lid status ??? */
 457
 458         radeon_connector_update_scratch_regs(connector, ret);
 459         return ret;
 460 }
 461
 462 static void radeon_connector_destroy(struct drm_connector *connector)
 463 {
 464         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 465
 466         if (radeon_connector->ddc_bus)
 467                 radeon_i2c_destroy(radeon_connector->ddc_bus);
 468         if (radeon_connector->edid)
 469                 kfree(radeon_connector->edid);
 470         kfree(radeon_connector->con_priv);
 471         drm_sysfs_connector_remove(connector);
 472         drm_connector_cleanup(connector);
 473         kfree(connector);
 474 }
 475
 476 static int radeon_lvds_set_property(struct drm_connector *connector,
 477                                     struct drm_property *property,
 478                                     uint64_t value)
 479 {
 480         struct drm_device *dev = connector->dev;
 481         struct radeon_encoder *radeon_encoder;
 482         enum radeon_rmx_type rmx_type;
 483
 484         DRM_DEBUG("\n");
 485         if (property != dev->mode_config.scaling_mode_property)
 486                 return 0;
 487
 488         if (connector->encoder)
 489                 radeon_encoder = to_radeon_encoder(connector->encoder);
 490         else {
 491                 struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
 492                 radeon_encoder = to_radeon_encoder(connector_funcs->best_encoder(connector));
 493         }
 494
 495         switch (value) {
 496         case DRM_MODE_SCALE_NONE: rmx_type = RMX_OFF; break;
 497         case DRM_MODE_SCALE_CENTER: rmx_type = RMX_CENTER; break;
 498         case DRM_MODE_SCALE_ASPECT: rmx_type = RMX_ASPECT; break;
 499         default:
 500         case DRM_MODE_SCALE_FULLSCREEN: rmx_type = RMX_FULL; break;
 501         }
 502         if (radeon_encoder->rmx_type == rmx_type)
 503                 return 0;
 504
 505         radeon_encoder->rmx_type = rmx_type;
 506
 507         radeon_property_change_mode(&radeon_encoder->base);
 508         return 0;
 509 }
 510
 511
 512 struct drm_connector_helper_funcs radeon_lvds_connector_helper_funcs = {
 513         .get_modes = radeon_lvds_get_modes,
 514         .mode_valid = radeon_lvds_mode_valid,
 515         .best_encoder = radeon_best_single_encoder,
 516 };
 517
 518 struct drm_connector_funcs radeon_lvds_connector_funcs = {
 519         .dpms = drm_helper_connector_dpms,
 520         .detect = radeon_lvds_detect,
 521         .fill_modes = drm_helper_probe_single_connector_modes,
 522         .destroy = radeon_connector_destroy,
 523         .set_property = radeon_lvds_set_property,
 524 };
 525
 526 static int radeon_vga_get_modes(struct drm_connector *connector)
 527 {
 528         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 529         int ret;
 530
 531         ret = radeon_ddc_get_modes(radeon_connector);
 532
 533         return ret;
 534 }
 535
 536 static int radeon_vga_mode_valid(struct drm_connector *connector,
 537                                   struct drm_display_mode *mode)
 538 {
 539         /* XXX check mode bandwidth */
 540         /* XXX verify against max DAC output frequency */
 541         return MODE_OK;
 542 }
 543
 544 static enum drm_connector_status radeon_vga_detect(struct drm_connector *connector)
 545 {
 546         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 547         struct drm_encoder *encoder;
 548         struct drm_encoder_helper_funcs *encoder_funcs;
 549         bool dret;
 550         enum drm_connector_status ret = connector_status_disconnected;
 551
 552         encoder = radeon_best_single_encoder(connector);
 553         if (!encoder)
 554                 ret = connector_status_disconnected;
 555
 556         radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
 557         dret = radeon_ddc_probe(radeon_connector);
 558         radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
 559         if (dret) {
 560                 if (radeon_connector->edid) {
 561                         kfree(radeon_connector->edid);
 562                         radeon_connector->edid = NULL;
 563                 }
 564                 radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
 565                 radeon_connector->edid = drm_get_edid(&radeon_connector->base, &radeon_connector->ddc_bus->adapter);
 566                 radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
 567
 568                 if (!radeon_connector->edid) {
 569                         DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
 570                                         drm_get_connector_name(connector));
 571                         ret = connector_status_connected;
 572                 } else {
 573                         radeon_connector->use_digital = !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
 574
 575                         /* some oems have boards with separate digital and analog connectors
 576                          * with a shared ddc line (often vga + hdmi)
 577                          */
 578                         if (radeon_connector->use_digital && radeon_connector->shared_ddc) {
 579                                 kfree(radeon_connector->edid);
 580                                 radeon_connector->edid = NULL;
 581                                 ret = connector_status_disconnected;
 582                         } else
 583                                 ret = connector_status_connected;
 584                 }
 585         } else {
 586                 if (radeon_connector->dac_load_detect) {
 587                         encoder_funcs = encoder->helper_private;
 588                         ret = encoder_funcs->detect(encoder, connector);
 589                 }
 590         }
 591
 592         if (ret == connector_status_connected)
 593                 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
 594         radeon_connector_update_scratch_regs(connector, ret);
 595         return ret;
 596 }
 597
 598 struct drm_connector_helper_funcs radeon_vga_connector_helper_funcs = {
 599         .get_modes = radeon_vga_get_modes,
 600         .mode_valid = radeon_vga_mode_valid,
 601         .best_encoder = radeon_best_single_encoder,
 602 };
 603
 604 struct drm_connector_funcs radeon_vga_connector_funcs = {
 605         .dpms = drm_helper_connector_dpms,
 606         .detect = radeon_vga_detect,
 607         .fill_modes = drm_helper_probe_single_connector_modes,
 608         .destroy = radeon_connector_destroy,
 609         .set_property = radeon_connector_set_property,
 610 };
 611
 612 static int radeon_tv_get_modes(struct drm_connector *connector)
 613 {
 614         struct drm_device *dev = connector->dev;
 615         struct radeon_device *rdev = dev->dev_private;
 616         struct drm_display_mode *tv_mode;
 617         struct drm_encoder *encoder;
 618
 619         encoder = radeon_best_single_encoder(connector);
 620         if (!encoder)
 621                 return 0;
 622
 623         /* avivo chips can scale any mode */
 624         if (rdev->family >= CHIP_RS600)
 625                 /* add scaled modes */
 626                 radeon_add_common_modes(encoder, connector);
 627         else {
 628                 /* only 800x600 is supported right now on pre-avivo chips */
 629                 tv_mode = drm_cvt_mode(dev, 800, 600, 60, false, false, false);
 630                 tv_mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
 631                 drm_mode_probed_add(connector, tv_mode);
 632         }
 633         return 1;
 634 }
 635
 636 static int radeon_tv_mode_valid(struct drm_connector *connector,
 637                                 struct drm_display_mode *mode)
 638 {
 639         if ((mode->hdisplay > 1024) || (mode->vdisplay > 768))
 640                 return MODE_CLOCK_RANGE;
 641         return MODE_OK;
 642 }
 643
 644 static enum drm_connector_status radeon_tv_detect(struct drm_connector *connector)
 645 {
 646         struct drm_encoder *encoder;
 647         struct drm_encoder_helper_funcs *encoder_funcs;
 648         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 649         enum drm_connector_status ret = connector_status_disconnected;
 650
 651         if (!radeon_connector->dac_load_detect)
 652                 return ret;
 653
 654         encoder = radeon_best_single_encoder(connector);
 655         if (!encoder)
 656                 ret = connector_status_disconnected;
 657         else {
 658                 encoder_funcs = encoder->helper_private;
 659                 ret = encoder_funcs->detect(encoder, connector);
 660         }
 661         if (ret == connector_status_connected)
 662                 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, false);
 663         radeon_connector_update_scratch_regs(connector, ret);
 664         return ret;
 665 }
 666
 667 struct drm_connector_helper_funcs radeon_tv_connector_helper_funcs = {
 668         .get_modes = radeon_tv_get_modes,
 669         .mode_valid = radeon_tv_mode_valid,
 670         .best_encoder = radeon_best_single_encoder,
 671 };
 672
 673 struct drm_connector_funcs radeon_tv_connector_funcs = {
 674         .dpms = drm_helper_connector_dpms,
 675         .detect = radeon_tv_detect,
 676         .fill_modes = drm_helper_probe_single_connector_modes,
 677         .destroy = radeon_connector_destroy,
 678         .set_property = radeon_connector_set_property,
 679 };
 680
 681 static int radeon_dvi_get_modes(struct drm_connector *connector)
 682 {
 683         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 684         int ret;
 685
 686         ret = radeon_ddc_get_modes(radeon_connector);
 687         return ret;
 688 }
 689
 690 /*
 691  * DVI is complicated
 692  * Do a DDC probe, if DDC probe passes, get the full EDID so
 693  * we can do analog/digital monitor detection at this point.
 694  * If the monitor is an analog monitor or we got no DDC,
 695  * we need to find the DAC encoder object for this connector.
 696  * If we got no DDC, we do load detection on the DAC encoder object.
 697  * If we got analog DDC or load detection passes on the DAC encoder
 698  * we have to check if this analog encoder is shared with anyone else (TV)
 699  * if its shared we have to set the other connector to disconnected.
 700  */
 701 static enum drm_connector_status radeon_dvi_detect(struct drm_connector *connector)
 702 {
 703         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 704         struct drm_encoder *encoder = NULL;
 705         struct drm_encoder_helper_funcs *encoder_funcs;
 706         struct drm_mode_object *obj;
 707         int i;
 708         enum drm_connector_status ret = connector_status_disconnected;
 709         bool dret;
 710
 711         radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
 712         dret = radeon_ddc_probe(radeon_connector);
 713         radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
 714         if (dret) {
 715                 if (radeon_connector->edid) {
 716                         kfree(radeon_connector->edid);
 717                         radeon_connector->edid = NULL;
 718                 }
 719                 radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
 720                 radeon_connector->edid = drm_get_edid(&radeon_connector->base, &radeon_connector->ddc_bus->adapter);
 721                 radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
 722
 723                 if (!radeon_connector->edid) {
 724                         DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
 725                                         drm_get_connector_name(connector));
 726                 } else {
 727                         radeon_connector->use_digital = !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
 728
 729                         /* some oems have boards with separate digital and analog connectors
 730                          * with a shared ddc line (often vga + hdmi)
 731                          */
 732                         if ((!radeon_connector->use_digital) && radeon_connector->shared_ddc) {
 733                                 kfree(radeon_connector->edid);
 734                                 radeon_connector->edid = NULL;
 735                                 ret = connector_status_disconnected;
 736                         } else
 737                                 ret = connector_status_connected;
 738
 739                         /* multiple connectors on the same encoder with the same ddc line
 740                          * This tends to be HDMI and DVI on the same encoder with the
 741                          * same ddc line.  If the edid says HDMI, consider the HDMI port
 742                          * connected and the DVI port disconnected.  If the edid doesn't
 743                          * say HDMI, vice versa.
 744                          */
 745                         if (radeon_connector->shared_ddc && connector_status_connected) {
 746                                 struct drm_device *dev = connector->dev;
 747                                 struct drm_connector *list_connector;
 748                                 struct radeon_connector *list_radeon_connector;
 749                                 list_for_each_entry(list_connector, &dev->mode_config.connector_list, head) {
 750                                         if (connector == list_connector)
 751                                                 continue;
 752                                         list_radeon_connector = to_radeon_connector(list_connector);
 753                                         if (radeon_connector->devices == list_radeon_connector->devices) {
 754                                                 if (drm_detect_hdmi_monitor(radeon_connector->edid)) {
 755                                                         if (connector->connector_type == DRM_MODE_CONNECTOR_DVID) {
 756                                                                 kfree(radeon_connector->edid);
 757                                                                 radeon_connector->edid = NULL;
 758                                                                 ret = connector_status_disconnected;
 759                                                         }
 760                                                 } else {
 761                                                         if ((connector->connector_type == DRM_MODE_CONNECTOR_HDMIA) ||
 762                                                             (connector->connector_type == DRM_MODE_CONNECTOR_HDMIB)) {
 763                                                                 kfree(radeon_connector->edid);
 764                                                                 radeon_connector->edid = NULL;
 765                                                                 ret = connector_status_disconnected;
 766                                                         }
 767                                                 }
 768                                         }
 769                                 }
 770                         }
 771                 }
 772         }
 773
 774         if ((ret == connector_status_connected) && (radeon_connector->use_digital == true))
 775                 goto out;
 776
 777         /* find analog encoder */
 778         if (radeon_connector->dac_load_detect) {
 779                 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
 780                         if (connector->encoder_ids[i] == 0)
 781                                 break;
 782
 783                         obj = drm_mode_object_find(connector->dev,
 784                                                    connector->encoder_ids[i],
 785                                                    DRM_MODE_OBJECT_ENCODER);
 786                         if (!obj)
 787                                 continue;
 788
 789                         encoder = obj_to_encoder(obj);
 790
 791                         encoder_funcs = encoder->helper_private;
 792                         if (encoder_funcs->detect) {
 793                                 if (ret != connector_status_connected) {
 794                                         ret = encoder_funcs->detect(encoder, connector);
 795                                         if (ret == connector_status_connected) {
 796                                                 radeon_connector->use_digital = false;
 797                                         }
 798                                 }
 799                                 break;
 800                         }
 801                 }
 802         }
 803
 804         if ((ret == connector_status_connected) && (radeon_connector->use_digital == false) &&
 805             encoder) {
 806                 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
 807         }
 808
 809 out:
 810         /* updated in get modes as well since we need to know if it's analog or digital */
 811         radeon_connector_update_scratch_regs(connector, ret);
 812         return ret;
 813 }
 814
 815 /* okay need to be smart in here about which encoder to pick */
 816 struct drm_encoder *radeon_dvi_encoder(struct drm_connector *connector)
 817 {
 818         int enc_id = connector->encoder_ids[0];
 819         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 820         struct drm_mode_object *obj;
 821         struct drm_encoder *encoder;
 822         int i;
 823         for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
 824                 if (connector->encoder_ids[i] == 0)
 825                         break;
 826
 827                 obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER);
 828                 if (!obj)
 829                         continue;
 830
 831                 encoder = obj_to_encoder(obj);
 832
 833                 if (radeon_connector->use_digital == true) {
 834                         if (encoder->encoder_type == DRM_MODE_ENCODER_TMDS)
 835                                 return encoder;
 836                 } else {
 837                         if (encoder->encoder_type == DRM_MODE_ENCODER_DAC ||
 838                             encoder->encoder_type == DRM_MODE_ENCODER_TVDAC)
 839                                 return encoder;
 840                 }
 841         }
 842
 843         /* see if we have a default encoder  TODO */
 844
 845         /* then check use digitial */
 846         /* pick the first one */
 847         if (enc_id) {
 848                 obj = drm_mode_object_find(connector->dev, enc_id, DRM_MODE_OBJECT_ENCODER);
 849                 if (!obj)
 850                         return NULL;
 851                 encoder = obj_to_encoder(obj);
 852                 return encoder;
 853         }
 854         return NULL;
 855 }
 856
 857 static void radeon_dvi_force(struct drm_connector *connector)
 858 {
 859         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 860         if (connector->force == DRM_FORCE_ON)
 861                 radeon_connector->use_digital = false;
 862         if (connector->force == DRM_FORCE_ON_DIGITAL)
 863                 radeon_connector->use_digital = true;
 864 }
 865
 866 static int radeon_dvi_mode_valid(struct drm_connector *connector,
 867                                   struct drm_display_mode *mode)
 868 {
 869         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 870
 871         /* XXX check mode bandwidth */
 872
 873         if (radeon_connector->use_digital && (mode->clock > 165000)) {
 874                 if ((radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_I) ||
 875                     (radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_D) ||
 876                     (radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_HDMI_TYPE_B))
 877                         return MODE_OK;
 878                 else
 879                         return MODE_CLOCK_HIGH;
 880         }
 881         return MODE_OK;
 882 }
 883
 884 struct drm_connector_helper_funcs radeon_dvi_connector_helper_funcs = {
 885         .get_modes = radeon_dvi_get_modes,
 886         .mode_valid = radeon_dvi_mode_valid,
 887         .best_encoder = radeon_dvi_encoder,
 888 };
 889
 890 struct drm_connector_funcs radeon_dvi_connector_funcs = {
 891         .dpms = drm_helper_connector_dpms,
 892         .detect = radeon_dvi_detect,
 893         .fill_modes = drm_helper_probe_single_connector_modes,
 894         .set_property = radeon_connector_set_property,
 895         .destroy = radeon_connector_destroy,
 896         .force = radeon_dvi_force,
 897 };
 898
 899 static void radeon_dp_connector_destroy(struct drm_connector *connector)
 900 {
 901         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 902         struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
 903
 904         if (radeon_connector->ddc_bus)
 905                 radeon_i2c_destroy(radeon_connector->ddc_bus);
 906         if (radeon_connector->edid)
 907                 kfree(radeon_connector->edid);
 908         if (radeon_dig_connector->dp_i2c_bus)
 909                 radeon_i2c_destroy(radeon_dig_connector->dp_i2c_bus);
 910         kfree(radeon_connector->con_priv);
 911         drm_sysfs_connector_remove(connector);
 912         drm_connector_cleanup(connector);
 913         kfree(connector);
 914 }
 915
 916 static int radeon_dp_get_modes(struct drm_connector *connector)
 917 {
 918         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 919         int ret;
 920
 921         ret = radeon_ddc_get_modes(radeon_connector);
 922         return ret;
 923 }
 924
 925 static enum drm_connector_status radeon_dp_detect(struct drm_connector *connector)
 926 {
 927         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 928         enum drm_connector_status ret = connector_status_disconnected;
 929         struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
 930         u8 sink_type;
 931
 932         if (radeon_connector->edid) {
 933                 kfree(radeon_connector->edid);
 934                 radeon_connector->edid = NULL;
 935         }
 936
 937         sink_type = radeon_dp_getsinktype(radeon_connector);
 938         if (sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) {
 939                 if (radeon_dp_getdpcd(radeon_connector)) {
 940                         radeon_dig_connector->dp_sink_type = sink_type;
 941                         ret = connector_status_connected;
 942                 }
 943         } else {
 944                 radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
 945                 if (radeon_ddc_probe(radeon_connector)) {
 946                         radeon_dig_connector->dp_sink_type = sink_type;
 947                         ret = connector_status_connected;
 948                 }
 949                 radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
 950         }
 951
 952         return ret;
 953 }
 954
 955 static int radeon_dp_mode_valid(struct drm_connector *connector,
 956                                   struct drm_display_mode *mode)
 957 {
 958         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 959         struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
 960
 961         /* XXX check mode bandwidth */
 962
 963         if (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT)
 964                 return radeon_dp_mode_valid_helper(radeon_connector, mode);
 965         else
 966                 return MODE_OK;
 967 }
 968
 969 struct drm_connector_helper_funcs radeon_dp_connector_helper_funcs = {
 970         .get_modes = radeon_dp_get_modes,
 971         .mode_valid = radeon_dp_mode_valid,
 972         .best_encoder = radeon_dvi_encoder,
 973 };
 974
 975 struct drm_connector_funcs radeon_dp_connector_funcs = {
 976         .dpms = drm_helper_connector_dpms,
 977         .detect = radeon_dp_detect,
 978         .fill_modes = drm_helper_probe_single_connector_modes,
 979         .set_property = radeon_connector_set_property,
 980         .destroy = radeon_dp_connector_destroy,
 981         .force = radeon_dvi_force,
 982 };
 983
 984 void
 985 radeon_add_atom_connector(struct drm_device *dev,
 986                           uint32_t connector_id,
 987                           uint32_t supported_device,
 988                           int connector_type,
 989                           struct radeon_i2c_bus_rec *i2c_bus,
 990                           bool linkb,
 991                           uint32_t igp_lane_info,
 992                           uint16_t connector_object_id)
 993 {
 994         struct radeon_device *rdev = dev->dev_private;
 995         struct drm_connector *connector;
 996         struct radeon_connector *radeon_connector;
 997         struct radeon_connector_atom_dig *radeon_dig_connector;
 998         uint32_t subpixel_order = SubPixelNone;
 999         bool shared_ddc = false;
1000         int ret;
1001
1002         /* fixme - tv/cv/din */
1003         if (connector_type == DRM_MODE_CONNECTOR_Unknown)
1004                 return;
1005
1006         /* see if we already added it */
1007         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
1008                 radeon_connector = to_radeon_connector(connector);
1009                 if (radeon_connector->connector_id == connector_id) {
1010                         radeon_connector->devices |= supported_device;
1011                         return;
1012                 }
1013                 if (radeon_connector->ddc_bus && i2c_bus->valid) {
1014                         if (memcmp(&radeon_connector->ddc_bus->rec, i2c_bus,
1015                                     sizeof(struct radeon_i2c_bus_rec)) == 0) {
1016                                 radeon_connector->shared_ddc = true;
1017                                 shared_ddc = true;
1018                         }
1019                 }
1020         }
1021
1022         radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
1023         if (!radeon_connector)
1024                 return;
1025
1026         connector = &radeon_connector->base;
1027
1028         radeon_connector->connector_id = connector_id;
1029         radeon_connector->devices = supported_device;
1030         radeon_connector->shared_ddc = shared_ddc;
1031         radeon_connector->connector_object_id = connector_object_id;
1032         switch (connector_type) {
1033         case DRM_MODE_CONNECTOR_VGA:
1034                 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1035                 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1036                 if (ret)
1037                         goto failed;
1038                 if (i2c_bus->valid) {
1039                         radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "VGA");
1040                         if (!radeon_connector->ddc_bus)
1041                                 goto failed;
1042                 }
1043                 radeon_connector->dac_load_detect = true;
1044                 drm_connector_attach_property(&radeon_connector->base,
1045                                               rdev->mode_info.load_detect_property,
1046                                               1);
1047                 break;
1048         case DRM_MODE_CONNECTOR_DVIA:
1049                 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1050                 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1051                 if (ret)
1052                         goto failed;
1053                 if (i2c_bus->valid) {
1054                         radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
1055                         if (!radeon_connector->ddc_bus)
1056                                 goto failed;
1057                 }
1058                 radeon_connector->dac_load_detect = true;
1059                 drm_connector_attach_property(&radeon_connector->base,
1060                                               rdev->mode_info.load_detect_property,
1061                                               1);
1062                 break;
1063         case DRM_MODE_CONNECTOR_DVII:
1064         case DRM_MODE_CONNECTOR_DVID:
1065                 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
1066                 if (!radeon_dig_connector)
1067                         goto failed;
1068                 radeon_dig_connector->linkb = linkb;
1069                 radeon_dig_connector->igp_lane_info = igp_lane_info;
1070                 radeon_connector->con_priv = radeon_dig_connector;
1071                 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
1072                 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
1073                 if (ret)
1074                         goto failed;
1075                 if (i2c_bus->valid) {
1076                         radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
1077                         if (!radeon_connector->ddc_bus)
1078                                 goto failed;
1079                 }
1080                 subpixel_order = SubPixelHorizontalRGB;
1081                 drm_connector_attach_property(&radeon_connector->base,
1082                                               rdev->mode_info.coherent_mode_property,
1083                                               1);
1084                 radeon_connector->dac_load_detect = true;
1085                 drm_connector_attach_property(&radeon_connector->base,
1086                                               rdev->mode_info.load_detect_property,
1087                                               1);
1088                 break;
1089         case DRM_MODE_CONNECTOR_HDMIA:
1090         case DRM_MODE_CONNECTOR_HDMIB:
1091                 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
1092                 if (!radeon_dig_connector)
1093                         goto failed;
1094                 radeon_dig_connector->linkb = linkb;
1095                 radeon_dig_connector->igp_lane_info = igp_lane_info;
1096                 radeon_connector->con_priv = radeon_dig_connector;
1097                 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
1098                 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
1099                 if (ret)
1100                         goto failed;
1101                 if (i2c_bus->valid) {
1102                         radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "HDMI");
1103                         if (!radeon_connector->ddc_bus)
1104                                 goto failed;
1105                 }
1106                 drm_connector_attach_property(&radeon_connector->base,
1107                                               rdev->mode_info.coherent_mode_property,
1108                                               1);
1109                 subpixel_order = SubPixelHorizontalRGB;
1110                 break;
1111         case DRM_MODE_CONNECTOR_DisplayPort:
1112                 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
1113                 if (!radeon_dig_connector)
1114                         goto failed;
1115                 radeon_dig_connector->linkb = linkb;
1116                 radeon_dig_connector->igp_lane_info = igp_lane_info;
1117                 radeon_connector->con_priv = radeon_dig_connector;
1118                 drm_connector_init(dev, &radeon_connector->base, &radeon_dp_connector_funcs, connector_type);
1119                 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dp_connector_helper_funcs);
1120                 if (ret)
1121                         goto failed;
1122                 /* add DP i2c bus */
1123                 radeon_dig_connector->dp_i2c_bus = radeon_i2c_create_dp(dev, i2c_bus, "DP-auxch");
1124                 if (i2c_bus->valid) {
1125                         radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DP");
1126                         if (!radeon_connector->ddc_bus)
1127                                 goto failed;
1128                 }
1129                 subpixel_order = SubPixelHorizontalRGB;
1130                 break;
1131         case DRM_MODE_CONNECTOR_SVIDEO:
1132         case DRM_MODE_CONNECTOR_Composite:
1133         case DRM_MODE_CONNECTOR_9PinDIN:
1134                 if (radeon_tv == 1) {
1135                         drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
1136                         ret = drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
1137                         if (ret)
1138                                 goto failed;
1139                         radeon_connector->dac_load_detect = true;
1140                         drm_connector_attach_property(&radeon_connector->base,
1141                                                       rdev->mode_info.load_detect_property,
1142                                                       1);
1143                         drm_connector_attach_property(&radeon_connector->base,
1144                                                       rdev->mode_info.tv_std_property,
1145                                                       1);
1146                 }
1147                 break;
1148         case DRM_MODE_CONNECTOR_LVDS:
1149                 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
1150                 if (!radeon_dig_connector)
1151                         goto failed;
1152                 radeon_dig_connector->linkb = linkb;
1153                 radeon_dig_connector->igp_lane_info = igp_lane_info;
1154                 radeon_connector->con_priv = radeon_dig_connector;
1155                 drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
1156                 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
1157                 if (ret)
1158                         goto failed;
1159                 if (i2c_bus->valid) {
1160                         radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "LVDS");
1161                         if (!radeon_connector->ddc_bus)
1162                                 goto failed;
1163                 }
1164                 drm_mode_create_scaling_mode_property(dev);
1165                 drm_connector_attach_property(&radeon_connector->base,
1166                                               dev->mode_config.scaling_mode_property,
1167                                               DRM_MODE_SCALE_FULLSCREEN);
1168                 subpixel_order = SubPixelHorizontalRGB;
1169                 break;
1170         }
1171
1172         connector->display_info.subpixel_order = subpixel_order;
1173         drm_sysfs_connector_add(connector);
1174         return;
1175
1176 failed:
1177         if (radeon_connector->ddc_bus)
1178                 radeon_i2c_destroy(radeon_connector->ddc_bus);
1179         drm_connector_cleanup(connector);
1180         kfree(connector);
1181 }
1182
1183 void
1184 radeon_add_legacy_connector(struct drm_device *dev,
1185                             uint32_t connector_id,
1186                             uint32_t supported_device,
1187                             int connector_type,
1188                             struct radeon_i2c_bus_rec *i2c_bus,
1189                             uint16_t connector_object_id)
1190 {
1191         struct radeon_device *rdev = dev->dev_private;
1192         struct drm_connector *connector;
1193         struct radeon_connector *radeon_connector;
1194         uint32_t subpixel_order = SubPixelNone;
1195         int ret;
1196
1197         /* fixme - tv/cv/din */
1198         if (connector_type == DRM_MODE_CONNECTOR_Unknown)
1199                 return;
1200
1201         /* see if we already added it */
1202         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
1203                 radeon_connector = to_radeon_connector(connector);
1204                 if (radeon_connector->connector_id == connector_id) {
1205                         radeon_connector->devices |= supported_device;
1206                         return;
1207                 }
1208         }
1209
1210         radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
1211         if (!radeon_connector)
1212                 return;
1213
1214         connector = &radeon_connector->base;
1215
1216         radeon_connector->connector_id = connector_id;
1217         radeon_connector->devices = supported_device;
1218         radeon_connector->connector_object_id = connector_object_id;
1219         switch (connector_type) {
1220         case DRM_MODE_CONNECTOR_VGA:
1221                 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1222                 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1223                 if (ret)
1224                         goto failed;
1225                 if (i2c_bus->valid) {
1226                         radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "VGA");
1227                         if (!radeon_connector->ddc_bus)
1228                                 goto failed;
1229                 }
1230                 radeon_connector->dac_load_detect = true;
1231                 drm_connector_attach_property(&radeon_connector->base,
1232                                               rdev->mode_info.load_detect_property,
1233                                               1);
1234                 break;
1235         case DRM_MODE_CONNECTOR_DVIA:
1236                 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1237                 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1238                 if (ret)
1239                         goto failed;
1240                 if (i2c_bus->valid) {
1241                         radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
1242                         if (!radeon_connector->ddc_bus)
1243                                 goto failed;
1244                 }
1245                 radeon_connector->dac_load_detect = true;
1246                 drm_connector_attach_property(&radeon_connector->base,
1247                                               rdev->mode_info.load_detect_property,
1248                                               1);
1249                 break;
1250         case DRM_MODE_CONNECTOR_DVII:
1251         case DRM_MODE_CONNECTOR_DVID:
1252                 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
1253                 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
1254                 if (ret)
1255                         goto failed;
1256                 if (i2c_bus->valid) {
1257                         radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
1258                         if (!radeon_connector->ddc_bus)
1259                                 goto failed;
1260                         radeon_connector->dac_load_detect = true;
1261                         drm_connector_attach_property(&radeon_connector->base,
1262                                                       rdev->mode_info.load_detect_property,
1263                                                       1);
1264                 }
1265                 subpixel_order = SubPixelHorizontalRGB;
1266                 break;
1267         case DRM_MODE_CONNECTOR_SVIDEO:
1268         case DRM_MODE_CONNECTOR_Composite:
1269         case DRM_MODE_CONNECTOR_9PinDIN:
1270                 if (radeon_tv == 1) {
1271                         drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
1272                         ret = drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
1273                         if (ret)
1274                                 goto failed;
1275                         radeon_connector->dac_load_detect = true;
1276                         /* RS400,RC410,RS480 chipset seems to report a lot
1277                          * of false positive on load detect, we haven't yet
1278                          * found a way to make load detect reliable on those
1279                          * chipset, thus just disable it for TV.
1280                          */
1281                         if (rdev->family == CHIP_RS400 || rdev->family == CHIP_RS480)
1282                                 radeon_connector->dac_load_detect = false;
1283                         drm_connector_attach_property(&radeon_connector->base,
1284                                                       rdev->mode_info.load_detect_property,
1285                                                       1);
1286                         drm_connector_attach_property(&radeon_connector->base,
1287                                                       rdev->mode_info.tv_std_property,
1288                                                       1);
1289                 }
1290                 break;
1291         case DRM_MODE_CONNECTOR_LVDS:
1292                 drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
1293                 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
1294                 if (ret)
1295                         goto failed;
1296                 if (i2c_bus->valid) {
1297                         radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "LVDS");
1298                         if (!radeon_connector->ddc_bus)
1299                                 goto failed;
1300                 }
1301                 drm_connector_attach_property(&radeon_connector->base,
1302                                               dev->mode_config.scaling_mode_property,
1303                                               DRM_MODE_SCALE_FULLSCREEN);
1304                 subpixel_order = SubPixelHorizontalRGB;
1305                 break;
1306         }
1307
1308         connector->display_info.subpixel_order = subpixel_order;
1309         drm_sysfs_connector_add(connector);
1310         return;
1311
1312 failed:
1313         if (radeon_connector->ddc_bus)
1314                 radeon_i2c_destroy(radeon_connector->ddc_bus);
1315         drm_connector_cleanup(connector);
1316         kfree(connector);
1317 }