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