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