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_create(dev);
 187                 *mode = *native_mode;
 188                 mode->type = DRM_MODE_TYPE_PREFERRED | DRM_MODE_TYPE_DRIVER;
 189                 drm_mode_set_name(mode);
 190
 191                 DRM_DEBUG("Adding native panel mode %s\n", mode->name);
 192         }
 193         return mode;
 194 }
 195
 196 static void radeon_add_common_modes(struct drm_encoder *encoder, struct drm_connector *connector)
 197 {
 198         struct drm_device *dev = encoder->dev;
 199         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
 200         struct drm_display_mode *mode = NULL;
 201         struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
 202         int i;
 203         struct mode_size {
 204                 int w;
 205                 int h;
 206         } common_modes[17] = {
 207                 { 640,  480},
 208                 { 720,  480},
 209                 { 800,  600},
 210                 { 848,  480},
 211                 {1024,  768},
 212                 {1152,  768},
 213                 {1280,  720},
 214                 {1280,  800},
 215                 {1280,  854},
 216                 {1280,  960},
 217                 {1280, 1024},
 218                 {1440,  900},
 219                 {1400, 1050},
 220                 {1680, 1050},
 221                 {1600, 1200},
 222                 {1920, 1080},
 223                 {1920, 1200}
 224         };
 225
 226         for (i = 0; i < 17; i++) {
 227                 if (radeon_encoder->devices & (ATOM_DEVICE_LCD_SUPPORT)) {
 228                         if (common_modes[i].w > native_mode->hdisplay ||
 229                             common_modes[i].h > native_mode->vdisplay ||
 230                             (common_modes[i].w == native_mode->hdisplay &&
 231                              common_modes[i].h == native_mode->vdisplay))
 232                                 continue;
 233                 }
 234                 if (common_modes[i].w < 320 || common_modes[i].h < 200)
 235                         continue;
 236
 237                 mode = drm_cvt_mode(dev, common_modes[i].w, common_modes[i].h, 60, false, false, false);
 238                 drm_mode_probed_add(connector, mode);
 239         }
 240 }
 241
 242 int radeon_connector_set_property(struct drm_connector *connector, struct drm_property *property,
 243                                   uint64_t val)
 244 {
 245         struct drm_device *dev = connector->dev;
 246         struct radeon_device *rdev = dev->dev_private;
 247         struct drm_encoder *encoder;
 248         struct radeon_encoder *radeon_encoder;
 249
 250         if (property == rdev->mode_info.coherent_mode_property) {
 251                 struct radeon_encoder_atom_dig *dig;
 252
 253                 /* need to find digital encoder on connector */
 254                 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
 255                 if (!encoder)
 256                         return 0;
 257
 258                 radeon_encoder = to_radeon_encoder(encoder);
 259
 260                 if (!radeon_encoder->enc_priv)
 261                         return 0;
 262
 263                 dig = radeon_encoder->enc_priv;
 264                 dig->coherent_mode = val ? true : false;
 265                 radeon_property_change_mode(&radeon_encoder->base);
 266         }
 267
 268         if (property == rdev->mode_info.tv_std_property) {
 269                 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TVDAC);
 270                 if (!encoder) {
 271                         encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_DAC);
 272                 }
 273
 274                 if (!encoder)
 275                         return 0;
 276
 277                 radeon_encoder = to_radeon_encoder(encoder);
 278                 if (!radeon_encoder->enc_priv)
 279                         return 0;
 280                 if (rdev->is_atom_bios) {
 281                         struct radeon_encoder_atom_dac *dac_int;
 282                         dac_int = radeon_encoder->enc_priv;
 283                         dac_int->tv_std = val;
 284                 } else {
 285                         struct radeon_encoder_tv_dac *dac_int;
 286                         dac_int = radeon_encoder->enc_priv;
 287                         dac_int->tv_std = val;
 288                 }
 289                 radeon_property_change_mode(&radeon_encoder->base);
 290         }
 291
 292         if (property == rdev->mode_info.load_detect_property) {
 293                 struct radeon_connector *radeon_connector =
 294                         to_radeon_connector(connector);
 295
 296                 if (val == 0)
 297                         radeon_connector->dac_load_detect = false;
 298                 else
 299                         radeon_connector->dac_load_detect = true;
 300         }
 301
 302         if (property == rdev->mode_info.tmds_pll_property) {
 303                 struct radeon_encoder_int_tmds *tmds = NULL;
 304                 bool ret = false;
 305                 /* need to find digital encoder on connector */
 306                 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
 307                 if (!encoder)
 308                         return 0;
 309
 310                 radeon_encoder = to_radeon_encoder(encoder);
 311
 312                 tmds = radeon_encoder->enc_priv;
 313                 if (!tmds)
 314                         return 0;
 315
 316                 if (val == 0) {
 317                         if (rdev->is_atom_bios)
 318                                 ret = radeon_atombios_get_tmds_info(radeon_encoder, tmds);
 319                         else
 320                                 ret = radeon_legacy_get_tmds_info_from_combios(radeon_encoder, tmds);
 321                 }
 322                 if (val == 1 || ret == false) {
 323                         radeon_legacy_get_tmds_info_from_table(radeon_encoder, tmds);
 324                 }
 325                 radeon_property_change_mode(&radeon_encoder->base);
 326         }
 327
 328         return 0;
 329 }
 330
 331 static void radeon_fixup_lvds_native_mode(struct drm_encoder *encoder,
 332                                           struct drm_connector *connector)
 333 {
 334         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
 335         struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
 336
 337         /* Try to get native mode details from EDID if necessary */
 338         if (!native_mode->clock) {
 339                 struct drm_display_mode *t, *mode;
 340
 341                 list_for_each_entry_safe(mode, t, &connector->probed_modes, head) {
 342                         if (mode->hdisplay == native_mode->hdisplay &&
 343                             mode->vdisplay == native_mode->vdisplay) {
 344                                 *native_mode = *mode;
 345                                 drm_mode_set_crtcinfo(native_mode, CRTC_INTERLACE_HALVE_V);
 346                                 DRM_INFO("Determined LVDS native mode details from EDID\n");
 347                                 break;
 348                         }
 349                 }
 350         }
 351         if (!native_mode->clock) {
 352                 DRM_INFO("No LVDS native mode details, disabling RMX\n");
 353                 radeon_encoder->rmx_type = RMX_OFF;
 354         }
 355 }
 356
 357 static int radeon_lvds_get_modes(struct drm_connector *connector)
 358 {
 359         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 360         struct drm_encoder *encoder;
 361         int ret = 0;
 362         struct drm_display_mode *mode;
 363
 364         if (radeon_connector->ddc_bus) {
 365                 ret = radeon_ddc_get_modes(radeon_connector);
 366                 if (ret > 0) {
 367                         encoder = radeon_best_single_encoder(connector);
 368                         if (encoder) {
 369                                 radeon_fixup_lvds_native_mode(encoder, connector);
 370                                 /* add scaled modes */
 371                                 radeon_add_common_modes(encoder, connector);
 372                         }
 373                         return ret;
 374                 }
 375         }
 376
 377         encoder = radeon_best_single_encoder(connector);
 378         if (!encoder)
 379                 return 0;
 380
 381         /* we have no EDID modes */
 382         mode = radeon_fp_native_mode(encoder);
 383         if (mode) {
 384                 ret = 1;
 385                 drm_mode_probed_add(connector, mode);
 386                 /* add scaled modes */
 387                 radeon_add_common_modes(encoder, connector);
 388         }
 389
 390         return ret;
 391 }
 392
 393 static int radeon_lvds_mode_valid(struct drm_connector *connector,
 394                                   struct drm_display_mode *mode)
 395 {
 396         return MODE_OK;
 397 }
 398
 399 static enum drm_connector_status radeon_lvds_detect(struct drm_connector *connector)
 400 {
 401         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 402         struct drm_encoder *encoder = radeon_best_single_encoder(connector);
 403         enum drm_connector_status ret = connector_status_disconnected;
 404         bool dret;
 405
 406         if (encoder) {
 407                 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
 408                 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
 409
 410                 /* check if panel is valid */
 411                 if (native_mode->hdisplay >= 320 && native_mode->vdisplay >= 240)
 412                         ret = connector_status_connected;
 413
 414         }
 415
 416         /* check for edid as well */
 417         if (radeon_connector->ddc_bus) {
 418                 radeon_i2c_do_lock(radeon_connector, 1);
 419                 dret = radeon_ddc_probe(radeon_connector);
 420                 radeon_i2c_do_lock(radeon_connector, 0);
 421                 if (dret)
 422                         ret = connector_status_connected;
 423         }
 424         /* check acpi lid status ??? */
 425
 426         radeon_connector_update_scratch_regs(connector, ret);
 427         return ret;
 428 }
 429
 430 static void radeon_connector_destroy(struct drm_connector *connector)
 431 {
 432         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 433
 434         if (radeon_connector->ddc_bus)
 435                 radeon_i2c_destroy(radeon_connector->ddc_bus);
 436         kfree(radeon_connector->con_priv);
 437         drm_sysfs_connector_remove(connector);
 438         drm_connector_cleanup(connector);
 439         kfree(connector);
 440 }
 441
 442 static int radeon_lvds_set_property(struct drm_connector *connector,
 443                                     struct drm_property *property,
 444                                     uint64_t value)
 445 {
 446         struct drm_device *dev = connector->dev;
 447         struct radeon_encoder *radeon_encoder;
 448         enum radeon_rmx_type rmx_type;
 449
 450         DRM_DEBUG("\n");
 451         if (property != dev->mode_config.scaling_mode_property)
 452                 return 0;
 453
 454         if (connector->encoder)
 455                 radeon_encoder = to_radeon_encoder(connector->encoder);
 456         else {
 457                 struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
 458                 radeon_encoder = to_radeon_encoder(connector_funcs->best_encoder(connector));
 459         }
 460
 461         switch (value) {
 462         case DRM_MODE_SCALE_NONE: rmx_type = RMX_OFF; break;
 463         case DRM_MODE_SCALE_CENTER: rmx_type = RMX_CENTER; break;
 464         case DRM_MODE_SCALE_ASPECT: rmx_type = RMX_ASPECT; break;
 465         default:
 466         case DRM_MODE_SCALE_FULLSCREEN: rmx_type = RMX_FULL; break;
 467         }
 468         if (radeon_encoder->rmx_type == rmx_type)
 469                 return 0;
 470
 471         radeon_encoder->rmx_type = rmx_type;
 472
 473         radeon_property_change_mode(&radeon_encoder->base);
 474         return 0;
 475 }
 476
 477
 478 struct drm_connector_helper_funcs radeon_lvds_connector_helper_funcs = {
 479         .get_modes = radeon_lvds_get_modes,
 480         .mode_valid = radeon_lvds_mode_valid,
 481         .best_encoder = radeon_best_single_encoder,
 482 };
 483
 484 struct drm_connector_funcs radeon_lvds_connector_funcs = {
 485         .dpms = drm_helper_connector_dpms,
 486         .detect = radeon_lvds_detect,
 487         .fill_modes = drm_helper_probe_single_connector_modes,
 488         .destroy = radeon_connector_destroy,
 489         .set_property = radeon_lvds_set_property,
 490 };
 491
 492 static int radeon_vga_get_modes(struct drm_connector *connector)
 493 {
 494         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 495         int ret;
 496
 497         ret = radeon_ddc_get_modes(radeon_connector);
 498
 499         return ret;
 500 }
 501
 502 static int radeon_vga_mode_valid(struct drm_connector *connector,
 503                                   struct drm_display_mode *mode)
 504 {
 505         return MODE_OK;
 506 }
 507
 508 static enum drm_connector_status radeon_vga_detect(struct drm_connector *connector)
 509 {
 510         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 511         struct drm_encoder *encoder;
 512         struct drm_encoder_helper_funcs *encoder_funcs;
 513         bool dret;
 514         enum drm_connector_status ret = connector_status_disconnected;
 515
 516         encoder = radeon_best_single_encoder(connector);
 517         if (!encoder)
 518                 ret = connector_status_disconnected;
 519
 520         radeon_i2c_do_lock(radeon_connector, 1);
 521         dret = radeon_ddc_probe(radeon_connector);
 522         radeon_i2c_do_lock(radeon_connector, 0);
 523         if (dret)
 524                 ret = connector_status_connected;
 525         else {
 526                 if (radeon_connector->dac_load_detect) {
 527                         encoder_funcs = encoder->helper_private;
 528                         ret = encoder_funcs->detect(encoder, connector);
 529                 }
 530         }
 531
 532         if (ret == connector_status_connected)
 533                 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
 534         radeon_connector_update_scratch_regs(connector, ret);
 535         return ret;
 536 }
 537
 538 struct drm_connector_helper_funcs radeon_vga_connector_helper_funcs = {
 539         .get_modes = radeon_vga_get_modes,
 540         .mode_valid = radeon_vga_mode_valid,
 541         .best_encoder = radeon_best_single_encoder,
 542 };
 543
 544 struct drm_connector_funcs radeon_vga_connector_funcs = {
 545         .dpms = drm_helper_connector_dpms,
 546         .detect = radeon_vga_detect,
 547         .fill_modes = drm_helper_probe_single_connector_modes,
 548         .destroy = radeon_connector_destroy,
 549         .set_property = radeon_connector_set_property,
 550 };
 551
 552 static int radeon_tv_get_modes(struct drm_connector *connector)
 553 {
 554         struct drm_device *dev = connector->dev;
 555         struct radeon_device *rdev = dev->dev_private;
 556         struct drm_display_mode *tv_mode;
 557         struct drm_encoder *encoder;
 558
 559         encoder = radeon_best_single_encoder(connector);
 560         if (!encoder)
 561                 return 0;
 562
 563         /* avivo chips can scale any mode */
 564         if (rdev->family >= CHIP_RS600)
 565                 /* add scaled modes */
 566                 radeon_add_common_modes(encoder, connector);
 567         else {
 568                 /* only 800x600 is supported right now on pre-avivo chips */
 569                 tv_mode = drm_cvt_mode(dev, 800, 600, 60, false, false, false);
 570                 tv_mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
 571                 drm_mode_probed_add(connector, tv_mode);
 572         }
 573         return 1;
 574 }
 575
 576 static int radeon_tv_mode_valid(struct drm_connector *connector,
 577                                 struct drm_display_mode *mode)
 578 {
 579         return MODE_OK;
 580 }
 581
 582 static enum drm_connector_status radeon_tv_detect(struct drm_connector *connector)
 583 {
 584         struct drm_encoder *encoder;
 585         struct drm_encoder_helper_funcs *encoder_funcs;
 586         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 587         enum drm_connector_status ret = connector_status_disconnected;
 588
 589         if (!radeon_connector->dac_load_detect)
 590                 return ret;
 591
 592         encoder = radeon_best_single_encoder(connector);
 593         if (!encoder)
 594                 ret = connector_status_disconnected;
 595         else {
 596                 encoder_funcs = encoder->helper_private;
 597                 ret = encoder_funcs->detect(encoder, connector);
 598         }
 599         if (ret == connector_status_connected)
 600                 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, false);
 601         radeon_connector_update_scratch_regs(connector, ret);
 602         return ret;
 603 }
 604
 605 struct drm_connector_helper_funcs radeon_tv_connector_helper_funcs = {
 606         .get_modes = radeon_tv_get_modes,
 607         .mode_valid = radeon_tv_mode_valid,
 608         .best_encoder = radeon_best_single_encoder,
 609 };
 610
 611 struct drm_connector_funcs radeon_tv_connector_funcs = {
 612         .dpms = drm_helper_connector_dpms,
 613         .detect = radeon_tv_detect,
 614         .fill_modes = drm_helper_probe_single_connector_modes,
 615         .destroy = radeon_connector_destroy,
 616         .set_property = radeon_connector_set_property,
 617 };
 618
 619 static int radeon_dvi_get_modes(struct drm_connector *connector)
 620 {
 621         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 622         int ret;
 623
 624         ret = radeon_ddc_get_modes(radeon_connector);
 625         return ret;
 626 }
 627
 628 /*
 629  * DVI is complicated
 630  * Do a DDC probe, if DDC probe passes, get the full EDID so
 631  * we can do analog/digital monitor detection at this point.
 632  * If the monitor is an analog monitor or we got no DDC,
 633  * we need to find the DAC encoder object for this connector.
 634  * If we got no DDC, we do load detection on the DAC encoder object.
 635  * If we got analog DDC or load detection passes on the DAC encoder
 636  * we have to check if this analog encoder is shared with anyone else (TV)
 637  * if its shared we have to set the other connector to disconnected.
 638  */
 639 static enum drm_connector_status radeon_dvi_detect(struct drm_connector *connector)
 640 {
 641         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 642         struct drm_encoder *encoder = NULL;
 643         struct drm_encoder_helper_funcs *encoder_funcs;
 644         struct drm_mode_object *obj;
 645         int i;
 646         enum drm_connector_status ret = connector_status_disconnected;
 647         bool dret;
 648
 649         radeon_i2c_do_lock(radeon_connector, 1);
 650         dret = radeon_ddc_probe(radeon_connector);
 651         radeon_i2c_do_lock(radeon_connector, 0);
 652         if (dret) {
 653                 radeon_i2c_do_lock(radeon_connector, 1);
 654                 radeon_connector->edid = drm_get_edid(&radeon_connector->base, &radeon_connector->ddc_bus->adapter);
 655                 radeon_i2c_do_lock(radeon_connector, 0);
 656
 657                 if (!radeon_connector->edid) {
 658                         DRM_ERROR("DDC responded but not EDID found for %s\n",
 659                                   drm_get_connector_name(connector));
 660                 } else {
 661                         radeon_connector->use_digital = !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
 662
 663                         /* if this isn't a digital monitor
 664                            then we need to make sure we don't have any
 665                            TV conflicts */
 666                         ret = connector_status_connected;
 667                 }
 668         }
 669
 670         if ((ret == connector_status_connected) && (radeon_connector->use_digital == true))
 671                 goto out;
 672
 673         /* find analog encoder */
 674         if (radeon_connector->dac_load_detect) {
 675                 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
 676                         if (connector->encoder_ids[i] == 0)
 677                                 break;
 678
 679                         obj = drm_mode_object_find(connector->dev,
 680                                                    connector->encoder_ids[i],
 681                                                    DRM_MODE_OBJECT_ENCODER);
 682                         if (!obj)
 683                                 continue;
 684
 685                         encoder = obj_to_encoder(obj);
 686
 687                         encoder_funcs = encoder->helper_private;
 688                         if (encoder_funcs->detect) {
 689                                 if (ret != connector_status_connected) {
 690                                         ret = encoder_funcs->detect(encoder, connector);
 691                                         if (ret == connector_status_connected) {
 692                                                 radeon_connector->use_digital = false;
 693                                         }
 694                                 }
 695                                 break;
 696                         }
 697                 }
 698         }
 699
 700         if ((ret == connector_status_connected) && (radeon_connector->use_digital == false) &&
 701             encoder) {
 702                 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
 703         }
 704
 705 out:
 706         /* updated in get modes as well since we need to know if it's analog or digital */
 707         radeon_connector_update_scratch_regs(connector, ret);
 708         return ret;
 709 }
 710
 711 /* okay need to be smart in here about which encoder to pick */
 712 struct drm_encoder *radeon_dvi_encoder(struct drm_connector *connector)
 713 {
 714         int enc_id = connector->encoder_ids[0];
 715         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 716         struct drm_mode_object *obj;
 717         struct drm_encoder *encoder;
 718         int i;
 719         for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
 720                 if (connector->encoder_ids[i] == 0)
 721                         break;
 722
 723                 obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER);
 724                 if (!obj)
 725                         continue;
 726
 727                 encoder = obj_to_encoder(obj);
 728
 729                 if (radeon_connector->use_digital == true) {
 730                         if (encoder->encoder_type == DRM_MODE_ENCODER_TMDS)
 731                                 return encoder;
 732                 } else {
 733                         if (encoder->encoder_type == DRM_MODE_ENCODER_DAC ||
 734                             encoder->encoder_type == DRM_MODE_ENCODER_TVDAC)
 735                                 return encoder;
 736                 }
 737         }
 738
 739         /* see if we have a default encoder  TODO */
 740
 741         /* then check use digitial */
 742         /* pick the first one */
 743         if (enc_id) {
 744                 obj = drm_mode_object_find(connector->dev, enc_id, DRM_MODE_OBJECT_ENCODER);
 745                 if (!obj)
 746                         return NULL;
 747                 encoder = obj_to_encoder(obj);
 748                 return encoder;
 749         }
 750         return NULL;
 751 }
 752
 753 static void radeon_dvi_force(struct drm_connector *connector)
 754 {
 755         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 756         if (connector->force == DRM_FORCE_ON)
 757                 radeon_connector->use_digital = false;
 758         if (connector->force == DRM_FORCE_ON_DIGITAL)
 759                 radeon_connector->use_digital = true;
 760 }
 761
 762 struct drm_connector_helper_funcs radeon_dvi_connector_helper_funcs = {
 763         .get_modes = radeon_dvi_get_modes,
 764         .mode_valid = radeon_vga_mode_valid,
 765         .best_encoder = radeon_dvi_encoder,
 766 };
 767
 768 struct drm_connector_funcs radeon_dvi_connector_funcs = {
 769         .dpms = drm_helper_connector_dpms,
 770         .detect = radeon_dvi_detect,
 771         .fill_modes = drm_helper_probe_single_connector_modes,
 772         .set_property = radeon_connector_set_property,
 773         .destroy = radeon_connector_destroy,
 774         .force = radeon_dvi_force,
 775 };
 776
 777 void
 778 radeon_add_atom_connector(struct drm_device *dev,
 779                           uint32_t connector_id,
 780                           uint32_t supported_device,
 781                           int connector_type,
 782                           struct radeon_i2c_bus_rec *i2c_bus,
 783                           bool linkb,
 784                           uint32_t igp_lane_info)
 785 {
 786         struct radeon_device *rdev = dev->dev_private;
 787         struct drm_connector *connector;
 788         struct radeon_connector *radeon_connector;
 789         struct radeon_connector_atom_dig *radeon_dig_connector;
 790         uint32_t subpixel_order = SubPixelNone;
 791         int ret;
 792
 793         /* fixme - tv/cv/din */
 794         if (connector_type == DRM_MODE_CONNECTOR_Unknown)
 795                 return;
 796
 797         /* see if we already added it */
 798         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
 799                 radeon_connector = to_radeon_connector(connector);
 800                 if (radeon_connector->connector_id == connector_id) {
 801                         radeon_connector->devices |= supported_device;
 802                         return;
 803                 }
 804         }
 805
 806         radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
 807         if (!radeon_connector)
 808                 return;
 809
 810         connector = &radeon_connector->base;
 811
 812         radeon_connector->connector_id = connector_id;
 813         radeon_connector->devices = supported_device;
 814         switch (connector_type) {
 815         case DRM_MODE_CONNECTOR_VGA:
 816                 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
 817                 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
 818                 if (ret)
 819                         goto failed;
 820                 if (i2c_bus->valid) {
 821                         radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "VGA");
 822                         if (!radeon_connector->ddc_bus)
 823                                 goto failed;
 824                 }
 825                 radeon_connector->dac_load_detect = true;
 826                 drm_connector_attach_property(&radeon_connector->base,
 827                                               rdev->mode_info.load_detect_property,
 828                                               1);
 829                 break;
 830         case DRM_MODE_CONNECTOR_DVIA:
 831                 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
 832                 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
 833                 if (ret)
 834                         goto failed;
 835                 if (i2c_bus->valid) {
 836                         radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
 837                         if (!radeon_connector->ddc_bus)
 838                                 goto failed;
 839                 }
 840                 radeon_connector->dac_load_detect = true;
 841                 drm_connector_attach_property(&radeon_connector->base,
 842                                               rdev->mode_info.load_detect_property,
 843                                               1);
 844                 break;
 845         case DRM_MODE_CONNECTOR_DVII:
 846         case DRM_MODE_CONNECTOR_DVID:
 847                 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
 848                 if (!radeon_dig_connector)
 849                         goto failed;
 850                 radeon_dig_connector->linkb = linkb;
 851                 radeon_dig_connector->igp_lane_info = igp_lane_info;
 852                 radeon_connector->con_priv = radeon_dig_connector;
 853                 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
 854                 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
 855                 if (ret)
 856                         goto failed;
 857                 if (i2c_bus->valid) {
 858                         radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
 859                         if (!radeon_connector->ddc_bus)
 860                                 goto failed;
 861                 }
 862                 subpixel_order = SubPixelHorizontalRGB;
 863                 drm_connector_attach_property(&radeon_connector->base,
 864                                               rdev->mode_info.coherent_mode_property,
 865                                               1);
 866                 radeon_connector->dac_load_detect = true;
 867                 drm_connector_attach_property(&radeon_connector->base,
 868                                               rdev->mode_info.load_detect_property,
 869                                               1);
 870                 break;
 871         case DRM_MODE_CONNECTOR_HDMIA:
 872         case DRM_MODE_CONNECTOR_HDMIB:
 873                 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
 874                 if (!radeon_dig_connector)
 875                         goto failed;
 876                 radeon_dig_connector->linkb = linkb;
 877                 radeon_dig_connector->igp_lane_info = igp_lane_info;
 878                 radeon_connector->con_priv = radeon_dig_connector;
 879                 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
 880                 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
 881                 if (ret)
 882                         goto failed;
 883                 if (i2c_bus->valid) {
 884                         radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "HDMI");
 885                         if (!radeon_connector->ddc_bus)
 886                                 goto failed;
 887                 }
 888                 drm_connector_attach_property(&radeon_connector->base,
 889                                               rdev->mode_info.coherent_mode_property,
 890                                               1);
 891                 subpixel_order = SubPixelHorizontalRGB;
 892                 break;
 893         case DRM_MODE_CONNECTOR_DisplayPort:
 894                 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
 895                 if (!radeon_dig_connector)
 896                         goto failed;
 897                 radeon_dig_connector->linkb = linkb;
 898                 radeon_dig_connector->igp_lane_info = igp_lane_info;
 899                 radeon_connector->con_priv = radeon_dig_connector;
 900                 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
 901                 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
 902                 if (ret)
 903                         goto failed;
 904                 if (i2c_bus->valid) {
 905                         radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DP");
 906                         if (!radeon_connector->ddc_bus)
 907                                 goto failed;
 908                 }
 909                 subpixel_order = SubPixelHorizontalRGB;
 910                 break;
 911         case DRM_MODE_CONNECTOR_SVIDEO:
 912         case DRM_MODE_CONNECTOR_Composite:
 913         case DRM_MODE_CONNECTOR_9PinDIN:
 914                 if (radeon_tv == 1) {
 915                         drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
 916                         ret = drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
 917                         if (ret)
 918                                 goto failed;
 919                         radeon_connector->dac_load_detect = true;
 920                         drm_connector_attach_property(&radeon_connector->base,
 921                                                       rdev->mode_info.load_detect_property,
 922                                                       1);
 923                 }
 924                 break;
 925         case DRM_MODE_CONNECTOR_LVDS:
 926                 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
 927                 if (!radeon_dig_connector)
 928                         goto failed;
 929                 radeon_dig_connector->linkb = linkb;
 930                 radeon_dig_connector->igp_lane_info = igp_lane_info;
 931                 radeon_connector->con_priv = radeon_dig_connector;
 932                 drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
 933                 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
 934                 if (ret)
 935                         goto failed;
 936                 if (i2c_bus->valid) {
 937                         radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "LVDS");
 938                         if (!radeon_connector->ddc_bus)
 939                                 goto failed;
 940                 }
 941                 drm_mode_create_scaling_mode_property(dev);
 942                 drm_connector_attach_property(&radeon_connector->base,
 943                                               dev->mode_config.scaling_mode_property,
 944                                               DRM_MODE_SCALE_FULLSCREEN);
 945                 subpixel_order = SubPixelHorizontalRGB;
 946                 break;
 947         }
 948
 949         connector->display_info.subpixel_order = subpixel_order;
 950         drm_sysfs_connector_add(connector);
 951         return;
 952
 953 failed:
 954         if (radeon_connector->ddc_bus)
 955                 radeon_i2c_destroy(radeon_connector->ddc_bus);
 956         drm_connector_cleanup(connector);
 957         kfree(connector);
 958 }
 959
 960 void
 961 radeon_add_legacy_connector(struct drm_device *dev,
 962                             uint32_t connector_id,
 963                             uint32_t supported_device,
 964                             int connector_type,
 965                             struct radeon_i2c_bus_rec *i2c_bus)
 966 {
 967         struct radeon_device *rdev = dev->dev_private;
 968         struct drm_connector *connector;
 969         struct radeon_connector *radeon_connector;
 970         uint32_t subpixel_order = SubPixelNone;
 971         int ret;
 972
 973         /* fixme - tv/cv/din */
 974         if (connector_type == DRM_MODE_CONNECTOR_Unknown)
 975                 return;
 976
 977         /* see if we already added it */
 978         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
 979                 radeon_connector = to_radeon_connector(connector);
 980                 if (radeon_connector->connector_id == connector_id) {
 981                         radeon_connector->devices |= supported_device;
 982                         return;
 983                 }
 984         }
 985
 986         radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
 987         if (!radeon_connector)
 988                 return;
 989
 990         connector = &radeon_connector->base;
 991
 992         radeon_connector->connector_id = connector_id;
 993         radeon_connector->devices = supported_device;
 994         switch (connector_type) {
 995         case DRM_MODE_CONNECTOR_VGA:
 996                 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
 997                 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
 998                 if (ret)
 999                         goto failed;
1000                 if (i2c_bus->valid) {
1001                         radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "VGA");
1002                         if (!radeon_connector->ddc_bus)
1003                                 goto failed;
1004                 }
1005                 radeon_connector->dac_load_detect = true;
1006                 drm_connector_attach_property(&radeon_connector->base,
1007                                               rdev->mode_info.load_detect_property,
1008                                               1);
1009                 break;
1010         case DRM_MODE_CONNECTOR_DVIA:
1011                 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1012                 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1013                 if (ret)
1014                         goto failed;
1015                 if (i2c_bus->valid) {
1016                         radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
1017                         if (!radeon_connector->ddc_bus)
1018                                 goto failed;
1019                 }
1020                 radeon_connector->dac_load_detect = true;
1021                 drm_connector_attach_property(&radeon_connector->base,
1022                                               rdev->mode_info.load_detect_property,
1023                                               1);
1024                 break;
1025         case DRM_MODE_CONNECTOR_DVII:
1026         case DRM_MODE_CONNECTOR_DVID:
1027                 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
1028                 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
1029                 if (ret)
1030                         goto failed;
1031                 if (i2c_bus->valid) {
1032                         radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
1033                         if (!radeon_connector->ddc_bus)
1034                                 goto failed;
1035                         radeon_connector->dac_load_detect = true;
1036                         drm_connector_attach_property(&radeon_connector->base,
1037                                                       rdev->mode_info.load_detect_property,
1038                                                       1);
1039                 }
1040                 subpixel_order = SubPixelHorizontalRGB;
1041                 break;
1042         case DRM_MODE_CONNECTOR_SVIDEO:
1043         case DRM_MODE_CONNECTOR_Composite:
1044         case DRM_MODE_CONNECTOR_9PinDIN:
1045                 if (radeon_tv == 1) {
1046                         drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
1047                         ret = drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
1048                         if (ret)
1049                                 goto failed;
1050                         radeon_connector->dac_load_detect = true;
1051                         drm_connector_attach_property(&radeon_connector->base,
1052                                                       rdev->mode_info.load_detect_property,
1053                                                       1);
1054                 }
1055                 break;
1056         case DRM_MODE_CONNECTOR_LVDS:
1057                 drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
1058                 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
1059                 if (ret)
1060                         goto failed;
1061                 if (i2c_bus->valid) {
1062                         radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "LVDS");
1063                         if (!radeon_connector->ddc_bus)
1064                                 goto failed;
1065                 }
1066                 drm_connector_attach_property(&radeon_connector->base,
1067                                               dev->mode_config.scaling_mode_property,
1068                                               DRM_MODE_SCALE_FULLSCREEN);
1069                 subpixel_order = SubPixelHorizontalRGB;
1070                 break;
1071         }
1072
1073         connector->display_info.subpixel_order = subpixel_order;
1074         drm_sysfs_connector_add(connector);
1075         return;
1076
1077 failed:
1078         if (radeon_connector->ddc_bus)
1079                 radeon_i2c_destroy(radeon_connector->ddc_bus);
1080         drm_connector_cleanup(connector);
1081         kfree(connector);
1082 }