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