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         return MODE_OK;
 401 }
 402
 403 static enum drm_connector_status radeon_lvds_detect(struct drm_connector *connector)
 404 {
 405         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 406         struct drm_encoder *encoder = radeon_best_single_encoder(connector);
 407         enum drm_connector_status ret = connector_status_disconnected;
 408
 409         if (encoder) {
 410                 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
 411                 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
 412
 413                 /* check if panel is valid */
 414                 if (native_mode->hdisplay >= 320 && native_mode->vdisplay >= 240)
 415                         ret = connector_status_connected;
 416
 417         }
 418
 419         /* check for edid as well */
 420         if (radeon_connector->edid)
 421                 ret = connector_status_connected;
 422         else {
 423                 if (radeon_connector->ddc_bus) {
 424                         radeon_i2c_do_lock(radeon_connector, 1);
 425                         radeon_connector->edid = drm_get_edid(&radeon_connector->base,
 426                                                               &radeon_connector->ddc_bus->adapter);
 427                         radeon_i2c_do_lock(radeon_connector, 0);
 428                         if (radeon_connector->edid)
 429                                 ret = connector_status_connected;
 430                 }
 431         }
 432         /* check acpi lid status ??? */
 433
 434         radeon_connector_update_scratch_regs(connector, ret);
 435         return ret;
 436 }
 437
 438 static void radeon_connector_destroy(struct drm_connector *connector)
 439 {
 440         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 441
 442         if (radeon_connector->ddc_bus)
 443                 radeon_i2c_destroy(radeon_connector->ddc_bus);
 444         if (radeon_connector->edid)
 445                 kfree(radeon_connector->edid);
 446         kfree(radeon_connector->con_priv);
 447         drm_sysfs_connector_remove(connector);
 448         drm_connector_cleanup(connector);
 449         kfree(connector);
 450 }
 451
 452 static int radeon_lvds_set_property(struct drm_connector *connector,
 453                                     struct drm_property *property,
 454                                     uint64_t value)
 455 {
 456         struct drm_device *dev = connector->dev;
 457         struct radeon_encoder *radeon_encoder;
 458         enum radeon_rmx_type rmx_type;
 459
 460         DRM_DEBUG("\n");
 461         if (property != dev->mode_config.scaling_mode_property)
 462                 return 0;
 463
 464         if (connector->encoder)
 465                 radeon_encoder = to_radeon_encoder(connector->encoder);
 466         else {
 467                 struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
 468                 radeon_encoder = to_radeon_encoder(connector_funcs->best_encoder(connector));
 469         }
 470
 471         switch (value) {
 472         case DRM_MODE_SCALE_NONE: rmx_type = RMX_OFF; break;
 473         case DRM_MODE_SCALE_CENTER: rmx_type = RMX_CENTER; break;
 474         case DRM_MODE_SCALE_ASPECT: rmx_type = RMX_ASPECT; break;
 475         default:
 476         case DRM_MODE_SCALE_FULLSCREEN: rmx_type = RMX_FULL; break;
 477         }
 478         if (radeon_encoder->rmx_type == rmx_type)
 479                 return 0;
 480
 481         radeon_encoder->rmx_type = rmx_type;
 482
 483         radeon_property_change_mode(&radeon_encoder->base);
 484         return 0;
 485 }
 486
 487
 488 struct drm_connector_helper_funcs radeon_lvds_connector_helper_funcs = {
 489         .get_modes = radeon_lvds_get_modes,
 490         .mode_valid = radeon_lvds_mode_valid,
 491         .best_encoder = radeon_best_single_encoder,
 492 };
 493
 494 struct drm_connector_funcs radeon_lvds_connector_funcs = {
 495         .dpms = drm_helper_connector_dpms,
 496         .detect = radeon_lvds_detect,
 497         .fill_modes = drm_helper_probe_single_connector_modes,
 498         .destroy = radeon_connector_destroy,
 499         .set_property = radeon_lvds_set_property,
 500 };
 501
 502 static int radeon_vga_get_modes(struct drm_connector *connector)
 503 {
 504         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 505         int ret;
 506
 507         ret = radeon_ddc_get_modes(radeon_connector);
 508
 509         return ret;
 510 }
 511
 512 static int radeon_vga_mode_valid(struct drm_connector *connector,
 513                                   struct drm_display_mode *mode)
 514 {
 515         return MODE_OK;
 516 }
 517
 518 static enum drm_connector_status radeon_vga_detect(struct drm_connector *connector)
 519 {
 520         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 521         struct drm_encoder *encoder;
 522         struct drm_encoder_helper_funcs *encoder_funcs;
 523         bool dret;
 524         enum drm_connector_status ret = connector_status_disconnected;
 525
 526         encoder = radeon_best_single_encoder(connector);
 527         if (!encoder)
 528                 ret = connector_status_disconnected;
 529
 530         radeon_i2c_do_lock(radeon_connector, 1);
 531         dret = radeon_ddc_probe(radeon_connector);
 532         radeon_i2c_do_lock(radeon_connector, 0);
 533         if (dret) {
 534                 if (radeon_connector->edid) {
 535                         kfree(radeon_connector->edid);
 536                         radeon_connector->edid = NULL;
 537                 }
 538                 radeon_i2c_do_lock(radeon_connector, 1);
 539                 radeon_connector->edid = drm_get_edid(&radeon_connector->base, &radeon_connector->ddc_bus->adapter);
 540                 radeon_i2c_do_lock(radeon_connector, 0);
 541
 542                 if (!radeon_connector->edid) {
 543                         DRM_ERROR("DDC responded but not EDID found for %s\n",
 544                                   drm_get_connector_name(connector));
 545                 } else {
 546                         radeon_connector->use_digital = !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
 547
 548                         /* some oems have boards with separate digital and analog connectors
 549                          * with a shared ddc line (often vga + hdmi)
 550                          */
 551                         if (radeon_connector->use_digital && radeon_connector->shared_ddc) {
 552                                 kfree(radeon_connector->edid);
 553                                 radeon_connector->edid = NULL;
 554                                 ret = connector_status_disconnected;
 555                         } else
 556                                 ret = connector_status_connected;
 557                 }
 558         } else {
 559                 if (radeon_connector->dac_load_detect) {
 560                         encoder_funcs = encoder->helper_private;
 561                         ret = encoder_funcs->detect(encoder, connector);
 562                 }
 563         }
 564
 565         if (ret == connector_status_connected)
 566                 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
 567         radeon_connector_update_scratch_regs(connector, ret);
 568         return ret;
 569 }
 570
 571 struct drm_connector_helper_funcs radeon_vga_connector_helper_funcs = {
 572         .get_modes = radeon_vga_get_modes,
 573         .mode_valid = radeon_vga_mode_valid,
 574         .best_encoder = radeon_best_single_encoder,
 575 };
 576
 577 struct drm_connector_funcs radeon_vga_connector_funcs = {
 578         .dpms = drm_helper_connector_dpms,
 579         .detect = radeon_vga_detect,
 580         .fill_modes = drm_helper_probe_single_connector_modes,
 581         .destroy = radeon_connector_destroy,
 582         .set_property = radeon_connector_set_property,
 583 };
 584
 585 static int radeon_tv_get_modes(struct drm_connector *connector)
 586 {
 587         struct drm_device *dev = connector->dev;
 588         struct radeon_device *rdev = dev->dev_private;
 589         struct drm_display_mode *tv_mode;
 590         struct drm_encoder *encoder;
 591
 592         encoder = radeon_best_single_encoder(connector);
 593         if (!encoder)
 594                 return 0;
 595
 596         /* avivo chips can scale any mode */
 597         if (rdev->family >= CHIP_RS600)
 598                 /* add scaled modes */
 599                 radeon_add_common_modes(encoder, connector);
 600         else {
 601                 /* only 800x600 is supported right now on pre-avivo chips */
 602                 tv_mode = drm_cvt_mode(dev, 800, 600, 60, false, false, false);
 603                 tv_mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
 604                 drm_mode_probed_add(connector, tv_mode);
 605         }
 606         return 1;
 607 }
 608
 609 static int radeon_tv_mode_valid(struct drm_connector *connector,
 610                                 struct drm_display_mode *mode)
 611 {
 612         return MODE_OK;
 613 }
 614
 615 static enum drm_connector_status radeon_tv_detect(struct drm_connector *connector)
 616 {
 617         struct drm_encoder *encoder;
 618         struct drm_encoder_helper_funcs *encoder_funcs;
 619         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 620         enum drm_connector_status ret = connector_status_disconnected;
 621
 622         if (!radeon_connector->dac_load_detect)
 623                 return ret;
 624
 625         encoder = radeon_best_single_encoder(connector);
 626         if (!encoder)
 627                 ret = connector_status_disconnected;
 628         else {
 629                 encoder_funcs = encoder->helper_private;
 630                 ret = encoder_funcs->detect(encoder, connector);
 631         }
 632         if (ret == connector_status_connected)
 633                 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, false);
 634         radeon_connector_update_scratch_regs(connector, ret);
 635         return ret;
 636 }
 637
 638 struct drm_connector_helper_funcs radeon_tv_connector_helper_funcs = {
 639         .get_modes = radeon_tv_get_modes,
 640         .mode_valid = radeon_tv_mode_valid,
 641         .best_encoder = radeon_best_single_encoder,
 642 };
 643
 644 struct drm_connector_funcs radeon_tv_connector_funcs = {
 645         .dpms = drm_helper_connector_dpms,
 646         .detect = radeon_tv_detect,
 647         .fill_modes = drm_helper_probe_single_connector_modes,
 648         .destroy = radeon_connector_destroy,
 649         .set_property = radeon_connector_set_property,
 650 };
 651
 652 static int radeon_dvi_get_modes(struct drm_connector *connector)
 653 {
 654         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 655         int ret;
 656
 657         ret = radeon_ddc_get_modes(radeon_connector);
 658         return ret;
 659 }
 660
 661 /*
 662  * DVI is complicated
 663  * Do a DDC probe, if DDC probe passes, get the full EDID so
 664  * we can do analog/digital monitor detection at this point.
 665  * If the monitor is an analog monitor or we got no DDC,
 666  * we need to find the DAC encoder object for this connector.
 667  * If we got no DDC, we do load detection on the DAC encoder object.
 668  * If we got analog DDC or load detection passes on the DAC encoder
 669  * we have to check if this analog encoder is shared with anyone else (TV)
 670  * if its shared we have to set the other connector to disconnected.
 671  */
 672 static enum drm_connector_status radeon_dvi_detect(struct drm_connector *connector)
 673 {
 674         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 675         struct drm_encoder *encoder = NULL;
 676         struct drm_encoder_helper_funcs *encoder_funcs;
 677         struct drm_mode_object *obj;
 678         int i;
 679         enum drm_connector_status ret = connector_status_disconnected;
 680         bool dret;
 681
 682         radeon_i2c_do_lock(radeon_connector, 1);
 683         dret = radeon_ddc_probe(radeon_connector);
 684         radeon_i2c_do_lock(radeon_connector, 0);
 685         if (dret) {
 686                 if (radeon_connector->edid) {
 687                         kfree(radeon_connector->edid);
 688                         radeon_connector->edid = NULL;
 689                 }
 690                 radeon_i2c_do_lock(radeon_connector, 1);
 691                 radeon_connector->edid = drm_get_edid(&radeon_connector->base, &radeon_connector->ddc_bus->adapter);
 692                 radeon_i2c_do_lock(radeon_connector, 0);
 693
 694                 if (!radeon_connector->edid) {
 695                         DRM_ERROR("DDC responded but not EDID found for %s\n",
 696                                   drm_get_connector_name(connector));
 697                 } else {
 698                         radeon_connector->use_digital = !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
 699
 700                         /* some oems have boards with separate digital and analog connectors
 701                          * with a shared ddc line (often vga + hdmi)
 702                          */
 703                         if ((!radeon_connector->use_digital) && radeon_connector->shared_ddc) {
 704                                 kfree(radeon_connector->edid);
 705                                 radeon_connector->edid = NULL;
 706                                 ret = connector_status_disconnected;
 707                         } else
 708                                 ret = connector_status_connected;
 709                 }
 710         }
 711
 712         if ((ret == connector_status_connected) && (radeon_connector->use_digital == true))
 713                 goto out;
 714
 715         /* find analog encoder */
 716         if (radeon_connector->dac_load_detect) {
 717                 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
 718                         if (connector->encoder_ids[i] == 0)
 719                                 break;
 720
 721                         obj = drm_mode_object_find(connector->dev,
 722                                                    connector->encoder_ids[i],
 723                                                    DRM_MODE_OBJECT_ENCODER);
 724                         if (!obj)
 725                                 continue;
 726
 727                         encoder = obj_to_encoder(obj);
 728
 729                         encoder_funcs = encoder->helper_private;
 730                         if (encoder_funcs->detect) {
 731                                 if (ret != connector_status_connected) {
 732                                         ret = encoder_funcs->detect(encoder, connector);
 733                                         if (ret == connector_status_connected) {
 734                                                 radeon_connector->use_digital = false;
 735                                         }
 736                                 }
 737                                 break;
 738                         }
 739                 }
 740         }
 741
 742         if ((ret == connector_status_connected) && (radeon_connector->use_digital == false) &&
 743             encoder) {
 744                 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
 745         }
 746
 747 out:
 748         /* updated in get modes as well since we need to know if it's analog or digital */
 749         radeon_connector_update_scratch_regs(connector, ret);
 750         return ret;
 751 }
 752
 753 /* okay need to be smart in here about which encoder to pick */
 754 struct drm_encoder *radeon_dvi_encoder(struct drm_connector *connector)
 755 {
 756         int enc_id = connector->encoder_ids[0];
 757         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 758         struct drm_mode_object *obj;
 759         struct drm_encoder *encoder;
 760         int i;
 761         for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
 762                 if (connector->encoder_ids[i] == 0)
 763                         break;
 764
 765                 obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER);
 766                 if (!obj)
 767                         continue;
 768
 769                 encoder = obj_to_encoder(obj);
 770
 771                 if (radeon_connector->use_digital == true) {
 772                         if (encoder->encoder_type == DRM_MODE_ENCODER_TMDS)
 773                                 return encoder;
 774                 } else {
 775                         if (encoder->encoder_type == DRM_MODE_ENCODER_DAC ||
 776                             encoder->encoder_type == DRM_MODE_ENCODER_TVDAC)
 777                                 return encoder;
 778                 }
 779         }
 780
 781         /* see if we have a default encoder  TODO */
 782
 783         /* then check use digitial */
 784         /* pick the first one */
 785         if (enc_id) {
 786                 obj = drm_mode_object_find(connector->dev, enc_id, DRM_MODE_OBJECT_ENCODER);
 787                 if (!obj)
 788                         return NULL;
 789                 encoder = obj_to_encoder(obj);
 790                 return encoder;
 791         }
 792         return NULL;
 793 }
 794
 795 static void radeon_dvi_force(struct drm_connector *connector)
 796 {
 797         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 798         if (connector->force == DRM_FORCE_ON)
 799                 radeon_connector->use_digital = false;
 800         if (connector->force == DRM_FORCE_ON_DIGITAL)
 801                 radeon_connector->use_digital = true;
 802 }
 803
 804 struct drm_connector_helper_funcs radeon_dvi_connector_helper_funcs = {
 805         .get_modes = radeon_dvi_get_modes,
 806         .mode_valid = radeon_vga_mode_valid,
 807         .best_encoder = radeon_dvi_encoder,
 808 };
 809
 810 struct drm_connector_funcs radeon_dvi_connector_funcs = {
 811         .dpms = drm_helper_connector_dpms,
 812         .detect = radeon_dvi_detect,
 813         .fill_modes = drm_helper_probe_single_connector_modes,
 814         .set_property = radeon_connector_set_property,
 815         .destroy = radeon_connector_destroy,
 816         .force = radeon_dvi_force,
 817 };
 818
 819 void
 820 radeon_add_atom_connector(struct drm_device *dev,
 821                           uint32_t connector_id,
 822                           uint32_t supported_device,
 823                           int connector_type,
 824                           struct radeon_i2c_bus_rec *i2c_bus,
 825                           bool linkb,
 826                           uint32_t igp_lane_info)
 827 {
 828         struct radeon_device *rdev = dev->dev_private;
 829         struct drm_connector *connector;
 830         struct radeon_connector *radeon_connector;
 831         struct radeon_connector_atom_dig *radeon_dig_connector;
 832         uint32_t subpixel_order = SubPixelNone;
 833         bool shared_ddc = false;
 834         int ret;
 835
 836         /* fixme - tv/cv/din */
 837         if (connector_type == DRM_MODE_CONNECTOR_Unknown)
 838                 return;
 839
 840         /* see if we already added it */
 841         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
 842                 radeon_connector = to_radeon_connector(connector);
 843                 if (radeon_connector->connector_id == connector_id) {
 844                         radeon_connector->devices |= supported_device;
 845                         return;
 846                 }
 847                 if (radeon_connector->ddc_bus && i2c_bus->valid) {
 848                         if (memcmp(&radeon_connector->ddc_bus->rec, i2c_bus,
 849                                     sizeof(struct radeon_i2c_bus_rec)) == 0) {
 850                                 radeon_connector->shared_ddc = true;
 851                                 shared_ddc = true;
 852                         }
 853                 }
 854         }
 855
 856         radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
 857         if (!radeon_connector)
 858                 return;
 859
 860         connector = &radeon_connector->base;
 861
 862         radeon_connector->connector_id = connector_id;
 863         radeon_connector->devices = supported_device;
 864         radeon_connector->shared_ddc = shared_ddc;
 865         switch (connector_type) {
 866         case DRM_MODE_CONNECTOR_VGA:
 867                 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
 868                 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
 869                 if (ret)
 870                         goto failed;
 871                 if (i2c_bus->valid) {
 872                         radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "VGA");
 873                         if (!radeon_connector->ddc_bus)
 874                                 goto failed;
 875                 }
 876                 radeon_connector->dac_load_detect = true;
 877                 drm_connector_attach_property(&radeon_connector->base,
 878                                               rdev->mode_info.load_detect_property,
 879                                               1);
 880                 break;
 881         case DRM_MODE_CONNECTOR_DVIA:
 882                 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
 883                 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
 884                 if (ret)
 885                         goto failed;
 886                 if (i2c_bus->valid) {
 887                         radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
 888                         if (!radeon_connector->ddc_bus)
 889                                 goto failed;
 890                 }
 891                 radeon_connector->dac_load_detect = true;
 892                 drm_connector_attach_property(&radeon_connector->base,
 893                                               rdev->mode_info.load_detect_property,
 894                                               1);
 895                 break;
 896         case DRM_MODE_CONNECTOR_DVII:
 897         case DRM_MODE_CONNECTOR_DVID:
 898                 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
 899                 if (!radeon_dig_connector)
 900                         goto failed;
 901                 radeon_dig_connector->linkb = linkb;
 902                 radeon_dig_connector->igp_lane_info = igp_lane_info;
 903                 radeon_connector->con_priv = radeon_dig_connector;
 904                 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
 905                 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
 906                 if (ret)
 907                         goto failed;
 908                 if (i2c_bus->valid) {
 909                         radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
 910                         if (!radeon_connector->ddc_bus)
 911                                 goto failed;
 912                 }
 913                 subpixel_order = SubPixelHorizontalRGB;
 914                 drm_connector_attach_property(&radeon_connector->base,
 915                                               rdev->mode_info.coherent_mode_property,
 916                                               1);
 917                 radeon_connector->dac_load_detect = true;
 918                 drm_connector_attach_property(&radeon_connector->base,
 919                                               rdev->mode_info.load_detect_property,
 920                                               1);
 921                 break;
 922         case DRM_MODE_CONNECTOR_HDMIA:
 923         case DRM_MODE_CONNECTOR_HDMIB:
 924                 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
 925                 if (!radeon_dig_connector)
 926                         goto failed;
 927                 radeon_dig_connector->linkb = linkb;
 928                 radeon_dig_connector->igp_lane_info = igp_lane_info;
 929                 radeon_connector->con_priv = radeon_dig_connector;
 930                 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
 931                 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
 932                 if (ret)
 933                         goto failed;
 934                 if (i2c_bus->valid) {
 935                         radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "HDMI");
 936                         if (!radeon_connector->ddc_bus)
 937                                 goto failed;
 938                 }
 939                 drm_connector_attach_property(&radeon_connector->base,
 940                                               rdev->mode_info.coherent_mode_property,
 941                                               1);
 942                 subpixel_order = SubPixelHorizontalRGB;
 943                 break;
 944         case DRM_MODE_CONNECTOR_DisplayPort:
 945                 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
 946                 if (!radeon_dig_connector)
 947                         goto failed;
 948                 radeon_dig_connector->linkb = linkb;
 949                 radeon_dig_connector->igp_lane_info = igp_lane_info;
 950                 radeon_connector->con_priv = radeon_dig_connector;
 951                 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
 952                 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
 953                 if (ret)
 954                         goto failed;
 955                 if (i2c_bus->valid) {
 956                         radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DP");
 957                         if (!radeon_connector->ddc_bus)
 958                                 goto failed;
 959                 }
 960                 subpixel_order = SubPixelHorizontalRGB;
 961                 break;
 962         case DRM_MODE_CONNECTOR_SVIDEO:
 963         case DRM_MODE_CONNECTOR_Composite:
 964         case DRM_MODE_CONNECTOR_9PinDIN:
 965                 if (radeon_tv == 1) {
 966                         drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
 967                         ret = drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
 968                         if (ret)
 969                                 goto failed;
 970                         radeon_connector->dac_load_detect = true;
 971                         drm_connector_attach_property(&radeon_connector->base,
 972                                                       rdev->mode_info.load_detect_property,
 973                                                       1);
 974                 }
 975                 break;
 976         case DRM_MODE_CONNECTOR_LVDS:
 977                 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
 978                 if (!radeon_dig_connector)
 979                         goto failed;
 980                 radeon_dig_connector->linkb = linkb;
 981                 radeon_dig_connector->igp_lane_info = igp_lane_info;
 982                 radeon_connector->con_priv = radeon_dig_connector;
 983                 drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
 984                 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
 985                 if (ret)
 986                         goto failed;
 987                 if (i2c_bus->valid) {
 988                         radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "LVDS");
 989                         if (!radeon_connector->ddc_bus)
 990                                 goto failed;
 991                 }
 992                 drm_mode_create_scaling_mode_property(dev);
 993                 drm_connector_attach_property(&radeon_connector->base,
 994                                               dev->mode_config.scaling_mode_property,
 995                                               DRM_MODE_SCALE_FULLSCREEN);
 996                 subpixel_order = SubPixelHorizontalRGB;
 997                 break;
 998         }
 999
1000         connector->display_info.subpixel_order = subpixel_order;
1001         drm_sysfs_connector_add(connector);
1002         return;
1003
1004 failed:
1005         if (radeon_connector->ddc_bus)
1006                 radeon_i2c_destroy(radeon_connector->ddc_bus);
1007         drm_connector_cleanup(connector);
1008         kfree(connector);
1009 }
1010
1011 void
1012 radeon_add_legacy_connector(struct drm_device *dev,
1013                             uint32_t connector_id,
1014                             uint32_t supported_device,
1015                             int connector_type,
1016                             struct radeon_i2c_bus_rec *i2c_bus)
1017 {
1018         struct radeon_device *rdev = dev->dev_private;
1019         struct drm_connector *connector;
1020         struct radeon_connector *radeon_connector;
1021         uint32_t subpixel_order = SubPixelNone;
1022         int ret;
1023
1024         /* fixme - tv/cv/din */
1025         if (connector_type == DRM_MODE_CONNECTOR_Unknown)
1026                 return;
1027
1028         /* see if we already added it */
1029         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
1030                 radeon_connector = to_radeon_connector(connector);
1031                 if (radeon_connector->connector_id == connector_id) {
1032                         radeon_connector->devices |= supported_device;
1033                         return;
1034                 }
1035         }
1036
1037         radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
1038         if (!radeon_connector)
1039                 return;
1040
1041         connector = &radeon_connector->base;
1042
1043         radeon_connector->connector_id = connector_id;
1044         radeon_connector->devices = supported_device;
1045         switch (connector_type) {
1046         case DRM_MODE_CONNECTOR_VGA:
1047                 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1048                 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1049                 if (ret)
1050                         goto failed;
1051                 if (i2c_bus->valid) {
1052                         radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "VGA");
1053                         if (!radeon_connector->ddc_bus)
1054                                 goto failed;
1055                 }
1056                 radeon_connector->dac_load_detect = true;
1057                 drm_connector_attach_property(&radeon_connector->base,
1058                                               rdev->mode_info.load_detect_property,
1059                                               1);
1060                 break;
1061         case DRM_MODE_CONNECTOR_DVIA:
1062                 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1063                 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1064                 if (ret)
1065                         goto failed;
1066                 if (i2c_bus->valid) {
1067                         radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
1068                         if (!radeon_connector->ddc_bus)
1069                                 goto failed;
1070                 }
1071                 radeon_connector->dac_load_detect = true;
1072                 drm_connector_attach_property(&radeon_connector->base,
1073                                               rdev->mode_info.load_detect_property,
1074                                               1);
1075                 break;
1076         case DRM_MODE_CONNECTOR_DVII:
1077         case DRM_MODE_CONNECTOR_DVID:
1078                 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
1079                 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
1080                 if (ret)
1081                         goto failed;
1082                 if (i2c_bus->valid) {
1083                         radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
1084                         if (!radeon_connector->ddc_bus)
1085                                 goto failed;
1086                         radeon_connector->dac_load_detect = true;
1087                         drm_connector_attach_property(&radeon_connector->base,
1088                                                       rdev->mode_info.load_detect_property,
1089                                                       1);
1090                 }
1091                 subpixel_order = SubPixelHorizontalRGB;
1092                 break;
1093         case DRM_MODE_CONNECTOR_SVIDEO:
1094         case DRM_MODE_CONNECTOR_Composite:
1095         case DRM_MODE_CONNECTOR_9PinDIN:
1096                 if (radeon_tv == 1) {
1097                         drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
1098                         ret = drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
1099                         if (ret)
1100                                 goto failed;
1101                         radeon_connector->dac_load_detect = true;
1102                         drm_connector_attach_property(&radeon_connector->base,
1103                                                       rdev->mode_info.load_detect_property,
1104                                                       1);
1105                 }
1106                 break;
1107         case DRM_MODE_CONNECTOR_LVDS:
1108                 drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
1109                 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
1110                 if (ret)
1111                         goto failed;
1112                 if (i2c_bus->valid) {
1113                         radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "LVDS");
1114                         if (!radeon_connector->ddc_bus)
1115                                 goto failed;
1116                 }
1117                 drm_connector_attach_property(&radeon_connector->base,
1118                                               dev->mode_config.scaling_mode_property,
1119                                               DRM_MODE_SCALE_FULLSCREEN);
1120                 subpixel_order = SubPixelHorizontalRGB;
1121                 break;
1122         }
1123
1124         connector->display_info.subpixel_order = subpixel_order;
1125         drm_sysfs_connector_add(connector);
1126         return;
1127
1128 failed:
1129         if (radeon_connector->ddc_bus)
1130                 radeon_i2c_destroy(radeon_connector->ddc_bus);
1131         drm_connector_cleanup(connector);
1132         kfree(connector);
1133 }