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