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