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