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