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->display_info.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->display_info.max_tmds_clock; 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_unregister(struct drm_connector *connector) 928 { 929 struct radeon_connector *radeon_connector = to_radeon_connector(connector); 930 931 if (radeon_connector->ddc_bus && radeon_connector->ddc_bus->has_aux) { 932 drm_dp_aux_unregister(&radeon_connector->ddc_bus->aux); 933 radeon_connector->ddc_bus->has_aux = false; 934 } 935 } 936 937 static void radeon_connector_destroy(struct drm_connector *connector) 938 { 939 struct radeon_connector *radeon_connector = to_radeon_connector(connector); 940 941 radeon_connector_free_edid(connector); 942 kfree(radeon_connector->con_priv); 943 drm_connector_unregister(connector); 944 drm_connector_cleanup(connector); 945 kfree(connector); 946 } 947 948 static int radeon_lvds_set_property(struct drm_connector *connector, 949 struct drm_property *property, 950 uint64_t value) 951 { 952 struct drm_device *dev = connector->dev; 953 struct radeon_encoder *radeon_encoder; 954 enum radeon_rmx_type rmx_type; 955 956 DRM_DEBUG_KMS("\n"); 957 if (property != dev->mode_config.scaling_mode_property) 958 return 0; 959 960 if (connector->encoder) 961 radeon_encoder = to_radeon_encoder(connector->encoder); 962 else { 963 const struct drm_connector_helper_funcs *connector_funcs = connector->helper_private; 964 radeon_encoder = to_radeon_encoder(connector_funcs->best_encoder(connector)); 965 } 966 967 switch (value) { 968 case DRM_MODE_SCALE_NONE: rmx_type = RMX_OFF; break; 969 case DRM_MODE_SCALE_CENTER: rmx_type = RMX_CENTER; break; 970 case DRM_MODE_SCALE_ASPECT: rmx_type = RMX_ASPECT; break; 971 default: 972 case DRM_MODE_SCALE_FULLSCREEN: rmx_type = RMX_FULL; break; 973 } 974 if (radeon_encoder->rmx_type == rmx_type) 975 return 0; 976 977 radeon_encoder->rmx_type = rmx_type; 978 979 radeon_property_change_mode(&radeon_encoder->base); 980 return 0; 981 } 982 983 984 static const struct drm_connector_helper_funcs radeon_lvds_connector_helper_funcs = { 985 .get_modes = radeon_lvds_get_modes, 986 .mode_valid = radeon_lvds_mode_valid, 987 .best_encoder = radeon_best_single_encoder, 988 }; 989 990 static const struct drm_connector_funcs radeon_lvds_connector_funcs = { 991 .dpms = drm_helper_connector_dpms, 992 .detect = radeon_lvds_detect, 993 .fill_modes = drm_helper_probe_single_connector_modes, 994 .early_unregister = radeon_connector_unregister, 995 .destroy = radeon_connector_destroy, 996 .set_property = radeon_lvds_set_property, 997 }; 998 999 static int radeon_vga_get_modes(struct drm_connector *connector) 1000 { 1001 int ret; 1002 1003 radeon_connector_get_edid(connector); 1004 ret = radeon_ddc_get_modes(connector); 1005 1006 radeon_get_native_mode(connector); 1007 1008 return ret; 1009 } 1010 1011 static enum drm_mode_status radeon_vga_mode_valid(struct drm_connector *connector, 1012 struct drm_display_mode *mode) 1013 { 1014 struct drm_device *dev = connector->dev; 1015 struct radeon_device *rdev = dev->dev_private; 1016 1017 /* XXX check mode bandwidth */ 1018 1019 if ((mode->clock / 10) > rdev->clock.max_pixel_clock) 1020 return MODE_CLOCK_HIGH; 1021 1022 return MODE_OK; 1023 } 1024 1025 static enum drm_connector_status 1026 radeon_vga_detect(struct drm_connector *connector, bool force) 1027 { 1028 struct drm_device *dev = connector->dev; 1029 struct radeon_device *rdev = dev->dev_private; 1030 struct radeon_connector *radeon_connector = to_radeon_connector(connector); 1031 struct drm_encoder *encoder; 1032 const struct drm_encoder_helper_funcs *encoder_funcs; 1033 bool dret = false; 1034 enum drm_connector_status ret = connector_status_disconnected; 1035 #ifdef PM_TODO 1036 int r; 1037 1038 r = pm_runtime_get_sync(connector->dev->dev); 1039 if (r < 0) 1040 return connector_status_disconnected; 1041 #endif 1042 1043 encoder = radeon_best_single_encoder(connector); 1044 if (!encoder) 1045 ret = connector_status_disconnected; 1046 1047 if (radeon_connector->ddc_bus) 1048 dret = radeon_ddc_probe(radeon_connector, false); 1049 if (dret) { 1050 radeon_connector->detected_by_load = false; 1051 radeon_connector_free_edid(connector); 1052 radeon_connector_get_edid(connector); 1053 1054 if (!radeon_connector->edid) { 1055 DRM_ERROR("%s: probed a monitor but no|invalid EDID\n", 1056 connector->name); 1057 ret = connector_status_connected; 1058 } else { 1059 radeon_connector->use_digital = 1060 !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL); 1061 1062 /* some oems have boards with separate digital and analog connectors 1063 * with a shared ddc line (often vga + hdmi) 1064 */ 1065 if (radeon_connector->use_digital && radeon_connector->shared_ddc) { 1066 radeon_connector_free_edid(connector); 1067 ret = connector_status_disconnected; 1068 } else { 1069 ret = connector_status_connected; 1070 } 1071 } 1072 } else { 1073 1074 /* if we aren't forcing don't do destructive polling */ 1075 if (!force) { 1076 /* only return the previous status if we last 1077 * detected a monitor via load. 1078 */ 1079 if (radeon_connector->detected_by_load) 1080 ret = connector->status; 1081 goto out; 1082 } 1083 1084 if (radeon_connector->dac_load_detect && encoder) { 1085 encoder_funcs = encoder->helper_private; 1086 ret = encoder_funcs->detect(encoder, connector); 1087 if (ret != connector_status_disconnected) 1088 radeon_connector->detected_by_load = true; 1089 } 1090 } 1091 1092 if (ret == connector_status_connected) 1093 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true); 1094 1095 /* RN50 and some RV100 asics in servers often have a hardcoded EDID in the 1096 * vbios to deal with KVMs. If we have one and are not able to detect a monitor 1097 * by other means, assume the CRT is connected and use that EDID. 1098 */ 1099 if ((!rdev->is_atom_bios) && 1100 (ret == connector_status_disconnected) && 1101 rdev->mode_info.bios_hardcoded_edid_size) { 1102 ret = connector_status_connected; 1103 } 1104 1105 radeon_connector_update_scratch_regs(connector, ret); 1106 1107 out: 1108 #ifdef PM_TODO 1109 pm_runtime_mark_last_busy(connector->dev->dev); 1110 pm_runtime_put_autosuspend(connector->dev->dev); 1111 #endif 1112 1113 return ret; 1114 } 1115 1116 static const struct drm_connector_helper_funcs radeon_vga_connector_helper_funcs = { 1117 .get_modes = radeon_vga_get_modes, 1118 .mode_valid = radeon_vga_mode_valid, 1119 .best_encoder = radeon_best_single_encoder, 1120 }; 1121 1122 static const struct drm_connector_funcs radeon_vga_connector_funcs = { 1123 .dpms = drm_helper_connector_dpms, 1124 .detect = radeon_vga_detect, 1125 .fill_modes = drm_helper_probe_single_connector_modes, 1126 .early_unregister = radeon_connector_unregister, 1127 .destroy = radeon_connector_destroy, 1128 .set_property = radeon_connector_set_property, 1129 }; 1130 1131 static int radeon_tv_get_modes(struct drm_connector *connector) 1132 { 1133 struct drm_device *dev = connector->dev; 1134 struct radeon_device *rdev = dev->dev_private; 1135 struct drm_display_mode *tv_mode; 1136 struct drm_encoder *encoder; 1137 1138 encoder = radeon_best_single_encoder(connector); 1139 if (!encoder) 1140 return 0; 1141 1142 /* avivo chips can scale any mode */ 1143 if (rdev->family >= CHIP_RS600) 1144 /* add scaled modes */ 1145 radeon_add_common_modes(encoder, connector); 1146 else { 1147 /* only 800x600 is supported right now on pre-avivo chips */ 1148 tv_mode = drm_cvt_mode(dev, 800, 600, 60, false, false, false); 1149 tv_mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED; 1150 drm_mode_probed_add(connector, tv_mode); 1151 } 1152 return 1; 1153 } 1154 1155 static enum drm_mode_status radeon_tv_mode_valid(struct drm_connector *connector, 1156 struct drm_display_mode *mode) 1157 { 1158 if ((mode->hdisplay > 1024) || (mode->vdisplay > 768)) 1159 return MODE_CLOCK_RANGE; 1160 return MODE_OK; 1161 } 1162 1163 static enum drm_connector_status 1164 radeon_tv_detect(struct drm_connector *connector, bool force) 1165 { 1166 struct drm_encoder *encoder; 1167 const struct drm_encoder_helper_funcs *encoder_funcs; 1168 struct radeon_connector *radeon_connector = to_radeon_connector(connector); 1169 enum drm_connector_status ret = connector_status_disconnected; 1170 #ifdef PM_TODO 1171 int r; 1172 #endif 1173 1174 if (!radeon_connector->dac_load_detect) 1175 return ret; 1176 1177 #ifdef PM_TODO 1178 r = pm_runtime_get_sync(connector->dev->dev); 1179 if (r < 0) 1180 return connector_status_disconnected; 1181 #endif 1182 1183 encoder = radeon_best_single_encoder(connector); 1184 if (!encoder) 1185 ret = connector_status_disconnected; 1186 else { 1187 encoder_funcs = encoder->helper_private; 1188 ret = encoder_funcs->detect(encoder, connector); 1189 } 1190 if (ret == connector_status_connected) 1191 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, false); 1192 radeon_connector_update_scratch_regs(connector, ret); 1193 #ifdef PM_TODO 1194 pm_runtime_mark_last_busy(connector->dev->dev); 1195 pm_runtime_put_autosuspend(connector->dev->dev); 1196 #endif 1197 return ret; 1198 } 1199 1200 static const struct drm_connector_helper_funcs radeon_tv_connector_helper_funcs = { 1201 .get_modes = radeon_tv_get_modes, 1202 .mode_valid = radeon_tv_mode_valid, 1203 .best_encoder = radeon_best_single_encoder, 1204 }; 1205 1206 static const struct drm_connector_funcs radeon_tv_connector_funcs = { 1207 .dpms = drm_helper_connector_dpms, 1208 .detect = radeon_tv_detect, 1209 .fill_modes = drm_helper_probe_single_connector_modes, 1210 .early_unregister = radeon_connector_unregister, 1211 .destroy = radeon_connector_destroy, 1212 .set_property = radeon_connector_set_property, 1213 }; 1214 1215 static bool radeon_check_hpd_status_unchanged(struct drm_connector *connector) 1216 { 1217 struct drm_device *dev = connector->dev; 1218 struct radeon_device *rdev = dev->dev_private; 1219 struct radeon_connector *radeon_connector = to_radeon_connector(connector); 1220 enum drm_connector_status status; 1221 1222 /* We only trust HPD on R600 and newer ASICS. */ 1223 if (rdev->family >= CHIP_R600 1224 && radeon_connector->hpd.hpd != RADEON_HPD_NONE) { 1225 if (radeon_hpd_sense(rdev, radeon_connector->hpd.hpd)) 1226 status = connector_status_connected; 1227 else 1228 status = connector_status_disconnected; 1229 if (connector->status == status) 1230 return true; 1231 } 1232 1233 return false; 1234 } 1235 1236 /* 1237 * DVI is complicated 1238 * Do a DDC probe, if DDC probe passes, get the full EDID so 1239 * we can do analog/digital monitor detection at this point. 1240 * If the monitor is an analog monitor or we got no DDC, 1241 * we need to find the DAC encoder object for this connector. 1242 * If we got no DDC, we do load detection on the DAC encoder object. 1243 * If we got analog DDC or load detection passes on the DAC encoder 1244 * we have to check if this analog encoder is shared with anyone else (TV) 1245 * if its shared we have to set the other connector to disconnected. 1246 */ 1247 static enum drm_connector_status 1248 radeon_dvi_detect(struct drm_connector *connector, bool force) 1249 { 1250 struct drm_device *dev = connector->dev; 1251 struct radeon_device *rdev = dev->dev_private; 1252 struct radeon_connector *radeon_connector = to_radeon_connector(connector); 1253 struct drm_encoder *encoder = NULL; 1254 const struct drm_encoder_helper_funcs *encoder_funcs; 1255 int i; 1256 enum drm_connector_status ret = connector_status_disconnected; 1257 bool dret = false, broken_edid = false; 1258 1259 #ifdef PM_TODO 1260 r = pm_runtime_get_sync(connector->dev->dev); 1261 if (r < 0) 1262 return connector_status_disconnected; 1263 #endif 1264 1265 if (radeon_connector->detected_hpd_without_ddc) { 1266 force = true; 1267 radeon_connector->detected_hpd_without_ddc = false; 1268 } 1269 1270 if (!force && radeon_check_hpd_status_unchanged(connector)) { 1271 ret = connector->status; 1272 goto exit; 1273 } 1274 1275 if (radeon_connector->ddc_bus) { 1276 dret = radeon_ddc_probe(radeon_connector, false); 1277 1278 /* Sometimes the pins required for the DDC probe on DVI 1279 * connectors don't make contact at the same time that the ones 1280 * for HPD do. If the DDC probe fails even though we had an HPD 1281 * signal, try again later */ 1282 if (!dret && !force && 1283 connector->status != connector_status_connected) { 1284 DRM_DEBUG_KMS("hpd detected without ddc, retrying in 1 second\n"); 1285 radeon_connector->detected_hpd_without_ddc = true; 1286 schedule_delayed_work(&rdev->hotplug_work, 1287 msecs_to_jiffies(1000)); 1288 goto exit; 1289 } 1290 } 1291 if (dret) { 1292 radeon_connector->detected_by_load = false; 1293 radeon_connector_free_edid(connector); 1294 radeon_connector_get_edid(connector); 1295 1296 if (!radeon_connector->edid) { 1297 DRM_ERROR("%s: probed a monitor but no|invalid EDID\n", 1298 connector->name); 1299 /* rs690 seems to have a problem with connectors not existing and always 1300 * return a block of 0's. If we see this just stop polling on this output */ 1301 if ((rdev->family == CHIP_RS690 || rdev->family == CHIP_RS740) && 1302 radeon_connector->base.null_edid_counter) { 1303 ret = connector_status_disconnected; 1304 DRM_ERROR("%s: detected RS690 floating bus bug, stopping ddc detect\n", 1305 connector->name); 1306 radeon_connector->ddc_bus = NULL; 1307 } else { 1308 ret = connector_status_connected; 1309 broken_edid = true; /* defer use_digital to later */ 1310 } 1311 } else { 1312 radeon_connector->use_digital = 1313 !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL); 1314 1315 /* some oems have boards with separate digital and analog connectors 1316 * with a shared ddc line (often vga + hdmi) 1317 */ 1318 if ((!radeon_connector->use_digital) && radeon_connector->shared_ddc) { 1319 radeon_connector_free_edid(connector); 1320 ret = connector_status_disconnected; 1321 } else { 1322 ret = connector_status_connected; 1323 } 1324 /* This gets complicated. We have boards with VGA + HDMI with a 1325 * shared DDC line and we have boards with DVI-D + HDMI with a shared 1326 * DDC line. The latter is more complex because with DVI<->HDMI adapters 1327 * you don't really know what's connected to which port as both are digital. 1328 */ 1329 if (radeon_connector->shared_ddc && (ret == connector_status_connected)) { 1330 struct drm_connector *list_connector; 1331 struct radeon_connector *list_radeon_connector; 1332 list_for_each_entry(list_connector, &dev->mode_config.connector_list, head) { 1333 if (connector == list_connector) 1334 continue; 1335 list_radeon_connector = to_radeon_connector(list_connector); 1336 if (list_radeon_connector->shared_ddc && 1337 (list_radeon_connector->ddc_bus->rec.i2c_id == 1338 radeon_connector->ddc_bus->rec.i2c_id)) { 1339 /* cases where both connectors are digital */ 1340 if (list_connector->connector_type != DRM_MODE_CONNECTOR_VGA) { 1341 /* hpd is our only option in this case */ 1342 if (!radeon_hpd_sense(rdev, radeon_connector->hpd.hpd)) { 1343 radeon_connector_free_edid(connector); 1344 ret = connector_status_disconnected; 1345 } 1346 } 1347 } 1348 } 1349 } 1350 } 1351 } 1352 1353 if ((ret == connector_status_connected) && (radeon_connector->use_digital == true)) 1354 goto out; 1355 1356 /* DVI-D and HDMI-A are digital only */ 1357 if ((connector->connector_type == DRM_MODE_CONNECTOR_DVID) || 1358 (connector->connector_type == DRM_MODE_CONNECTOR_HDMIA)) 1359 goto out; 1360 1361 /* if we aren't forcing don't do destructive polling */ 1362 if (!force) { 1363 /* only return the previous status if we last 1364 * detected a monitor via load. 1365 */ 1366 if (radeon_connector->detected_by_load) 1367 ret = connector->status; 1368 goto out; 1369 } 1370 1371 /* find analog encoder */ 1372 if (radeon_connector->dac_load_detect) { 1373 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) { 1374 if (connector->encoder_ids[i] == 0) 1375 break; 1376 1377 encoder = drm_encoder_find(connector->dev, 1378 connector->encoder_ids[i]); 1379 if (!encoder) 1380 continue; 1381 1382 if (encoder->encoder_type != DRM_MODE_ENCODER_DAC && 1383 encoder->encoder_type != DRM_MODE_ENCODER_TVDAC) 1384 continue; 1385 1386 encoder_funcs = encoder->helper_private; 1387 if (encoder_funcs->detect) { 1388 if (!broken_edid) { 1389 if (ret != connector_status_connected) { 1390 /* deal with analog monitors without DDC */ 1391 ret = encoder_funcs->detect(encoder, connector); 1392 if (ret == connector_status_connected) { 1393 radeon_connector->use_digital = false; 1394 } 1395 if (ret != connector_status_disconnected) 1396 radeon_connector->detected_by_load = true; 1397 } 1398 } else { 1399 enum drm_connector_status lret; 1400 /* assume digital unless load detected otherwise */ 1401 radeon_connector->use_digital = true; 1402 lret = encoder_funcs->detect(encoder, connector); 1403 DRM_DEBUG_KMS("load_detect %x returned: %x\n",encoder->encoder_type,lret); 1404 if (lret == connector_status_connected) 1405 radeon_connector->use_digital = false; 1406 } 1407 break; 1408 } 1409 } 1410 } 1411 1412 if ((ret == connector_status_connected) && (radeon_connector->use_digital == false) && 1413 encoder) { 1414 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true); 1415 } 1416 1417 /* RN50 and some RV100 asics in servers often have a hardcoded EDID in the 1418 * vbios to deal with KVMs. If we have one and are not able to detect a monitor 1419 * by other means, assume the DFP is connected and use that EDID. In most 1420 * cases the DVI port is actually a virtual KVM port connected to the service 1421 * processor. 1422 */ 1423 out: 1424 if ((!rdev->is_atom_bios) && 1425 (ret == connector_status_disconnected) && 1426 rdev->mode_info.bios_hardcoded_edid_size) { 1427 radeon_connector->use_digital = true; 1428 ret = connector_status_connected; 1429 } 1430 1431 /* updated in get modes as well since we need to know if it's analog or digital */ 1432 radeon_connector_update_scratch_regs(connector, ret); 1433 1434 if ((radeon_audio != 0) && radeon_connector->use_digital) { 1435 const struct drm_connector_helper_funcs *connector_funcs = 1436 connector->helper_private; 1437 1438 encoder = connector_funcs->best_encoder(connector); 1439 if (encoder && (encoder->encoder_type == DRM_MODE_ENCODER_TMDS)) { 1440 radeon_connector_get_edid(connector); 1441 radeon_audio_detect(connector, encoder, ret); 1442 } 1443 } 1444 1445 exit: 1446 #ifdef PM_TODO 1447 pm_runtime_mark_last_busy(connector->dev->dev); 1448 pm_runtime_put_autosuspend(connector->dev->dev); 1449 #endif 1450 1451 return ret; 1452 } 1453 1454 /* okay need to be smart in here about which encoder to pick */ 1455 static struct drm_encoder *radeon_dvi_encoder(struct drm_connector *connector) 1456 { 1457 int enc_id = connector->encoder_ids[0]; 1458 struct radeon_connector *radeon_connector = to_radeon_connector(connector); 1459 struct drm_encoder *encoder; 1460 int i; 1461 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) { 1462 if (connector->encoder_ids[i] == 0) 1463 break; 1464 1465 encoder = drm_encoder_find(connector->dev, connector->encoder_ids[i]); 1466 if (!encoder) 1467 continue; 1468 1469 if (radeon_connector->use_digital == true) { 1470 if (encoder->encoder_type == DRM_MODE_ENCODER_TMDS) 1471 return encoder; 1472 } else { 1473 if (encoder->encoder_type == DRM_MODE_ENCODER_DAC || 1474 encoder->encoder_type == DRM_MODE_ENCODER_TVDAC) 1475 return encoder; 1476 } 1477 } 1478 1479 /* see if we have a default encoder TODO */ 1480 1481 /* then check use digitial */ 1482 /* pick the first one */ 1483 if (enc_id) 1484 return drm_encoder_find(connector->dev, enc_id); 1485 return NULL; 1486 } 1487 1488 static void radeon_dvi_force(struct drm_connector *connector) 1489 { 1490 struct radeon_connector *radeon_connector = to_radeon_connector(connector); 1491 if (connector->force == DRM_FORCE_ON) 1492 radeon_connector->use_digital = false; 1493 if (connector->force == DRM_FORCE_ON_DIGITAL) 1494 radeon_connector->use_digital = true; 1495 } 1496 1497 static enum drm_mode_status radeon_dvi_mode_valid(struct drm_connector *connector, 1498 struct drm_display_mode *mode) 1499 { 1500 struct drm_device *dev = connector->dev; 1501 struct radeon_device *rdev = dev->dev_private; 1502 struct radeon_connector *radeon_connector = to_radeon_connector(connector); 1503 1504 /* XXX check mode bandwidth */ 1505 1506 /* clocks over 135 MHz have heat issues with DVI on RV100 */ 1507 if (radeon_connector->use_digital && 1508 (rdev->family == CHIP_RV100) && 1509 (mode->clock > 135000)) 1510 return MODE_CLOCK_HIGH; 1511 1512 if (radeon_connector->use_digital && (mode->clock > 165000)) { 1513 if ((radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_I) || 1514 (radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_D) || 1515 (radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_HDMI_TYPE_B)) 1516 return MODE_OK; 1517 else if (ASIC_IS_DCE6(rdev) && drm_detect_hdmi_monitor(radeon_connector_edid(connector))) { 1518 /* HDMI 1.3+ supports max clock of 340 Mhz */ 1519 if (mode->clock > 340000) 1520 return MODE_CLOCK_HIGH; 1521 else 1522 return MODE_OK; 1523 } else { 1524 return MODE_CLOCK_HIGH; 1525 } 1526 } 1527 1528 /* check against the max pixel clock */ 1529 if ((mode->clock / 10) > rdev->clock.max_pixel_clock) 1530 return MODE_CLOCK_HIGH; 1531 1532 return MODE_OK; 1533 } 1534 1535 static const struct drm_connector_helper_funcs radeon_dvi_connector_helper_funcs = { 1536 .get_modes = radeon_vga_get_modes, 1537 .mode_valid = radeon_dvi_mode_valid, 1538 .best_encoder = radeon_dvi_encoder, 1539 }; 1540 1541 static const struct drm_connector_funcs radeon_dvi_connector_funcs = { 1542 .dpms = drm_helper_connector_dpms, 1543 .detect = radeon_dvi_detect, 1544 .fill_modes = drm_helper_probe_single_connector_modes, 1545 .set_property = radeon_connector_set_property, 1546 .early_unregister = radeon_connector_unregister, 1547 .destroy = radeon_connector_destroy, 1548 .force = radeon_dvi_force, 1549 }; 1550 1551 static int radeon_dp_get_modes(struct drm_connector *connector) 1552 { 1553 struct radeon_connector *radeon_connector = to_radeon_connector(connector); 1554 struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv; 1555 struct drm_encoder *encoder = radeon_best_single_encoder(connector); 1556 int ret; 1557 1558 if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) || 1559 (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) { 1560 struct drm_display_mode *mode; 1561 1562 if (connector->connector_type == DRM_MODE_CONNECTOR_eDP) { 1563 if (!radeon_dig_connector->edp_on) 1564 atombios_set_edp_panel_power(connector, 1565 ATOM_TRANSMITTER_ACTION_POWER_ON); 1566 radeon_connector_get_edid(connector); 1567 ret = radeon_ddc_get_modes(connector); 1568 if (!radeon_dig_connector->edp_on) 1569 atombios_set_edp_panel_power(connector, 1570 ATOM_TRANSMITTER_ACTION_POWER_OFF); 1571 } else { 1572 /* need to setup ddc on the bridge */ 1573 if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector) != 1574 ENCODER_OBJECT_ID_NONE) { 1575 if (encoder) 1576 radeon_atom_ext_encoder_setup_ddc(encoder); 1577 } 1578 radeon_connector_get_edid(connector); 1579 ret = radeon_ddc_get_modes(connector); 1580 } 1581 1582 if (ret > 0) { 1583 if (encoder) { 1584 radeon_fixup_lvds_native_mode(encoder, connector); 1585 /* add scaled modes */ 1586 radeon_add_common_modes(encoder, connector); 1587 } 1588 return ret; 1589 } 1590 1591 if (!encoder) 1592 return 0; 1593 1594 /* we have no EDID modes */ 1595 mode = radeon_fp_native_mode(encoder); 1596 if (mode) { 1597 ret = 1; 1598 drm_mode_probed_add(connector, mode); 1599 /* add the width/height from vbios tables if available */ 1600 connector->display_info.width_mm = mode->width_mm; 1601 connector->display_info.height_mm = mode->height_mm; 1602 /* add scaled modes */ 1603 radeon_add_common_modes(encoder, connector); 1604 } 1605 } else { 1606 /* need to setup ddc on the bridge */ 1607 if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector) != 1608 ENCODER_OBJECT_ID_NONE) { 1609 if (encoder) 1610 radeon_atom_ext_encoder_setup_ddc(encoder); 1611 } 1612 radeon_connector_get_edid(connector); 1613 ret = radeon_ddc_get_modes(connector); 1614 1615 radeon_get_native_mode(connector); 1616 } 1617 1618 return ret; 1619 } 1620 1621 u16 radeon_connector_encoder_get_dp_bridge_encoder_id(struct drm_connector *connector) 1622 { 1623 struct drm_encoder *encoder; 1624 struct radeon_encoder *radeon_encoder; 1625 int i; 1626 1627 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) { 1628 if (connector->encoder_ids[i] == 0) 1629 break; 1630 1631 encoder = drm_encoder_find(connector->dev, connector->encoder_ids[i]); 1632 if (!encoder) 1633 continue; 1634 1635 radeon_encoder = to_radeon_encoder(encoder); 1636 1637 switch (radeon_encoder->encoder_id) { 1638 case ENCODER_OBJECT_ID_TRAVIS: 1639 case ENCODER_OBJECT_ID_NUTMEG: 1640 return radeon_encoder->encoder_id; 1641 default: 1642 break; 1643 } 1644 } 1645 1646 return ENCODER_OBJECT_ID_NONE; 1647 } 1648 1649 static bool radeon_connector_encoder_is_hbr2(struct drm_connector *connector) 1650 { 1651 struct drm_encoder *encoder; 1652 struct radeon_encoder *radeon_encoder; 1653 int i; 1654 bool found = false; 1655 1656 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) { 1657 if (connector->encoder_ids[i] == 0) 1658 break; 1659 1660 encoder = drm_encoder_find(connector->dev, connector->encoder_ids[i]); 1661 if (!encoder) 1662 continue; 1663 1664 radeon_encoder = to_radeon_encoder(encoder); 1665 if (radeon_encoder->caps & ATOM_ENCODER_CAP_RECORD_HBR2) 1666 found = true; 1667 } 1668 1669 return found; 1670 } 1671 1672 bool radeon_connector_is_dp12_capable(struct drm_connector *connector) 1673 { 1674 struct drm_device *dev = connector->dev; 1675 struct radeon_device *rdev = dev->dev_private; 1676 1677 if (ASIC_IS_DCE5(rdev) && 1678 (rdev->clock.default_dispclk >= 53900) && 1679 radeon_connector_encoder_is_hbr2(connector)) { 1680 return true; 1681 } 1682 1683 return false; 1684 } 1685 1686 static enum drm_connector_status 1687 radeon_dp_detect(struct drm_connector *connector, bool force) 1688 { 1689 struct drm_device *dev = connector->dev; 1690 struct radeon_device *rdev = dev->dev_private; 1691 struct radeon_connector *radeon_connector = to_radeon_connector(connector); 1692 enum drm_connector_status ret = connector_status_disconnected; 1693 struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv; 1694 struct drm_encoder *encoder = radeon_best_single_encoder(connector); 1695 int r; 1696 1697 if (radeon_dig_connector->is_mst) 1698 return connector_status_disconnected; 1699 1700 #ifdef PM_TODO 1701 r = pm_runtime_get_sync(connector->dev->dev); 1702 if (r < 0) 1703 return connector_status_disconnected; 1704 #endif 1705 1706 if (!force && radeon_check_hpd_status_unchanged(connector)) { 1707 ret = connector->status; 1708 goto out; 1709 } 1710 1711 radeon_connector_free_edid(connector); 1712 1713 if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) || 1714 (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) { 1715 if (encoder) { 1716 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder); 1717 struct drm_display_mode *native_mode = &radeon_encoder->native_mode; 1718 1719 /* check if panel is valid */ 1720 if (native_mode->hdisplay >= 320 && native_mode->vdisplay >= 240) 1721 ret = connector_status_connected; 1722 /* don't fetch the edid from the vbios if ddc fails and runpm is 1723 * enabled so we report disconnected. 1724 */ 1725 if ((rdev->flags & RADEON_IS_PX) && (radeon_runtime_pm != 0)) 1726 ret = connector_status_disconnected; 1727 } 1728 /* eDP is always DP */ 1729 radeon_dig_connector->dp_sink_type = CONNECTOR_OBJECT_ID_DISPLAYPORT; 1730 if (!radeon_dig_connector->edp_on) 1731 atombios_set_edp_panel_power(connector, 1732 ATOM_TRANSMITTER_ACTION_POWER_ON); 1733 if (radeon_dp_getdpcd(radeon_connector)) 1734 ret = connector_status_connected; 1735 if (!radeon_dig_connector->edp_on) 1736 atombios_set_edp_panel_power(connector, 1737 ATOM_TRANSMITTER_ACTION_POWER_OFF); 1738 } else if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector) != 1739 ENCODER_OBJECT_ID_NONE) { 1740 /* DP bridges are always DP */ 1741 radeon_dig_connector->dp_sink_type = CONNECTOR_OBJECT_ID_DISPLAYPORT; 1742 /* get the DPCD from the bridge */ 1743 radeon_dp_getdpcd(radeon_connector); 1744 1745 if (encoder) { 1746 /* setup ddc on the bridge */ 1747 radeon_atom_ext_encoder_setup_ddc(encoder); 1748 /* bridge chips are always aux */ 1749 if (radeon_ddc_probe(radeon_connector, true)) /* try DDC */ 1750 ret = connector_status_connected; 1751 else if (radeon_connector->dac_load_detect) { /* try load detection */ 1752 const struct drm_encoder_helper_funcs *encoder_funcs = encoder->helper_private; 1753 ret = encoder_funcs->detect(encoder, connector); 1754 } 1755 } 1756 } else { 1757 radeon_dig_connector->dp_sink_type = radeon_dp_getsinktype(radeon_connector); 1758 if (radeon_hpd_sense(rdev, radeon_connector->hpd.hpd)) { 1759 ret = connector_status_connected; 1760 if (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) { 1761 radeon_dp_getdpcd(radeon_connector); 1762 r = radeon_dp_mst_probe(radeon_connector); 1763 if (r == 1) 1764 ret = connector_status_disconnected; 1765 } 1766 } else { 1767 if (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) { 1768 if (radeon_dp_getdpcd(radeon_connector)) { 1769 r = radeon_dp_mst_probe(radeon_connector); 1770 if (r == 1) 1771 ret = connector_status_disconnected; 1772 else 1773 ret = connector_status_connected; 1774 } 1775 } else { 1776 /* try non-aux ddc (DP to DVI/HDMI/etc. adapter) */ 1777 if (radeon_ddc_probe(radeon_connector, false)) 1778 ret = connector_status_connected; 1779 } 1780 } 1781 } 1782 1783 radeon_connector_update_scratch_regs(connector, ret); 1784 1785 if ((radeon_audio != 0) && encoder) { 1786 radeon_connector_get_edid(connector); 1787 radeon_audio_detect(connector, encoder, ret); 1788 } 1789 1790 out: 1791 #ifdef PM_TODO 1792 pm_runtime_mark_last_busy(connector->dev->dev); 1793 pm_runtime_put_autosuspend(connector->dev->dev); 1794 #endif 1795 1796 return ret; 1797 } 1798 1799 static enum drm_mode_status radeon_dp_mode_valid(struct drm_connector *connector, 1800 struct drm_display_mode *mode) 1801 { 1802 struct drm_device *dev = connector->dev; 1803 struct radeon_device *rdev = dev->dev_private; 1804 struct radeon_connector *radeon_connector = to_radeon_connector(connector); 1805 struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv; 1806 1807 /* XXX check mode bandwidth */ 1808 1809 if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) || 1810 (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) { 1811 struct drm_encoder *encoder = radeon_best_single_encoder(connector); 1812 1813 if ((mode->hdisplay < 320) || (mode->vdisplay < 240)) 1814 return MODE_PANEL; 1815 1816 if (encoder) { 1817 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder); 1818 struct drm_display_mode *native_mode = &radeon_encoder->native_mode; 1819 1820 /* AVIVO hardware supports downscaling modes larger than the panel 1821 * to the panel size, but I'm not sure this is desirable. 1822 */ 1823 if ((mode->hdisplay > native_mode->hdisplay) || 1824 (mode->vdisplay > native_mode->vdisplay)) 1825 return MODE_PANEL; 1826 1827 /* if scaling is disabled, block non-native modes */ 1828 if (radeon_encoder->rmx_type == RMX_OFF) { 1829 if ((mode->hdisplay != native_mode->hdisplay) || 1830 (mode->vdisplay != native_mode->vdisplay)) 1831 return MODE_PANEL; 1832 } 1833 } 1834 } else { 1835 if ((radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) || 1836 (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_eDP)) { 1837 return radeon_dp_mode_valid_helper(connector, mode); 1838 } else { 1839 if (ASIC_IS_DCE6(rdev) && drm_detect_hdmi_monitor(radeon_connector_edid(connector))) { 1840 /* HDMI 1.3+ supports max clock of 340 Mhz */ 1841 if (mode->clock > 340000) 1842 return MODE_CLOCK_HIGH; 1843 } else { 1844 if (mode->clock > 165000) 1845 return MODE_CLOCK_HIGH; 1846 } 1847 } 1848 } 1849 1850 return MODE_OK; 1851 } 1852 1853 static const struct drm_connector_helper_funcs radeon_dp_connector_helper_funcs = { 1854 .get_modes = radeon_dp_get_modes, 1855 .mode_valid = radeon_dp_mode_valid, 1856 .best_encoder = radeon_dvi_encoder, 1857 }; 1858 1859 static const struct drm_connector_funcs radeon_dp_connector_funcs = { 1860 .dpms = drm_helper_connector_dpms, 1861 .detect = radeon_dp_detect, 1862 .fill_modes = drm_helper_probe_single_connector_modes, 1863 .set_property = radeon_connector_set_property, 1864 .early_unregister = radeon_connector_unregister, 1865 .destroy = radeon_connector_destroy, 1866 .force = radeon_dvi_force, 1867 }; 1868 1869 static const struct drm_connector_funcs radeon_edp_connector_funcs = { 1870 .dpms = drm_helper_connector_dpms, 1871 .detect = radeon_dp_detect, 1872 .fill_modes = drm_helper_probe_single_connector_modes, 1873 .set_property = radeon_lvds_set_property, 1874 .early_unregister = radeon_connector_unregister, 1875 .destroy = radeon_connector_destroy, 1876 .force = radeon_dvi_force, 1877 }; 1878 1879 static const struct drm_connector_funcs radeon_lvds_bridge_connector_funcs = { 1880 .dpms = drm_helper_connector_dpms, 1881 .detect = radeon_dp_detect, 1882 .fill_modes = drm_helper_probe_single_connector_modes, 1883 .set_property = radeon_lvds_set_property, 1884 .destroy = radeon_connector_destroy, 1885 .force = radeon_dvi_force, 1886 }; 1887 1888 void 1889 radeon_add_atom_connector(struct drm_device *dev, 1890 uint32_t connector_id, 1891 uint32_t supported_device, 1892 int connector_type, 1893 struct radeon_i2c_bus_rec *i2c_bus, 1894 uint32_t igp_lane_info, 1895 uint16_t connector_object_id, 1896 struct radeon_hpd *hpd, 1897 struct radeon_router *router) 1898 { 1899 struct radeon_device *rdev = dev->dev_private; 1900 struct drm_connector *connector; 1901 struct radeon_connector *radeon_connector; 1902 struct radeon_connector_atom_dig *radeon_dig_connector; 1903 struct drm_encoder *encoder; 1904 struct radeon_encoder *radeon_encoder; 1905 uint32_t subpixel_order = SubPixelNone; 1906 bool shared_ddc = false; 1907 bool is_dp_bridge = false; 1908 bool has_aux = false; 1909 1910 if (connector_type == DRM_MODE_CONNECTOR_Unknown) 1911 return; 1912 1913 /* if the user selected tv=0 don't try and add the connector */ 1914 if (((connector_type == DRM_MODE_CONNECTOR_SVIDEO) || 1915 (connector_type == DRM_MODE_CONNECTOR_Composite) || 1916 (connector_type == DRM_MODE_CONNECTOR_9PinDIN)) && 1917 (radeon_tv == 0)) 1918 return; 1919 1920 /* see if we already added it */ 1921 list_for_each_entry(connector, &dev->mode_config.connector_list, head) { 1922 radeon_connector = to_radeon_connector(connector); 1923 if (radeon_connector->connector_id == connector_id) { 1924 radeon_connector->devices |= supported_device; 1925 return; 1926 } 1927 if (radeon_connector->ddc_bus && i2c_bus->valid) { 1928 if (radeon_connector->ddc_bus->rec.i2c_id == i2c_bus->i2c_id) { 1929 radeon_connector->shared_ddc = true; 1930 shared_ddc = true; 1931 } 1932 if (radeon_connector->router_bus && router->ddc_valid && 1933 (radeon_connector->router.router_id == router->router_id)) { 1934 radeon_connector->shared_ddc = false; 1935 shared_ddc = false; 1936 } 1937 } 1938 } 1939 1940 /* check if it's a dp bridge */ 1941 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) { 1942 radeon_encoder = to_radeon_encoder(encoder); 1943 if (radeon_encoder->devices & supported_device) { 1944 switch (radeon_encoder->encoder_id) { 1945 case ENCODER_OBJECT_ID_TRAVIS: 1946 case ENCODER_OBJECT_ID_NUTMEG: 1947 is_dp_bridge = true; 1948 break; 1949 default: 1950 break; 1951 } 1952 } 1953 } 1954 1955 radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL); 1956 if (!radeon_connector) 1957 return; 1958 1959 connector = &radeon_connector->base; 1960 1961 radeon_connector->connector_id = connector_id; 1962 radeon_connector->devices = supported_device; 1963 radeon_connector->shared_ddc = shared_ddc; 1964 radeon_connector->connector_object_id = connector_object_id; 1965 radeon_connector->hpd = *hpd; 1966 1967 radeon_connector->router = *router; 1968 if (router->ddc_valid || router->cd_valid) { 1969 radeon_connector->router_bus = radeon_i2c_lookup(rdev, &router->i2c_info); 1970 if (!radeon_connector->router_bus) 1971 DRM_ERROR("Failed to assign router i2c bus! Check dmesg for i2c errors.\n"); 1972 } 1973 1974 if (is_dp_bridge) { 1975 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL); 1976 if (!radeon_dig_connector) 1977 goto failed; 1978 radeon_dig_connector->igp_lane_info = igp_lane_info; 1979 radeon_connector->con_priv = radeon_dig_connector; 1980 if (i2c_bus->valid) { 1981 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus); 1982 if (radeon_connector->ddc_bus) 1983 has_aux = true; 1984 else 1985 DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n"); 1986 } 1987 switch (connector_type) { 1988 case DRM_MODE_CONNECTOR_VGA: 1989 case DRM_MODE_CONNECTOR_DVIA: 1990 default: 1991 drm_connector_init(dev, &radeon_connector->base, 1992 &radeon_dp_connector_funcs, connector_type); 1993 drm_connector_helper_add(&radeon_connector->base, 1994 &radeon_dp_connector_helper_funcs); 1995 connector->interlace_allowed = true; 1996 connector->doublescan_allowed = true; 1997 radeon_connector->dac_load_detect = true; 1998 drm_object_attach_property(&radeon_connector->base.base, 1999 rdev->mode_info.load_detect_property, 2000 1); 2001 drm_object_attach_property(&radeon_connector->base.base, 2002 dev->mode_config.scaling_mode_property, 2003 DRM_MODE_SCALE_NONE); 2004 if (ASIC_IS_DCE5(rdev)) 2005 drm_object_attach_property(&radeon_connector->base.base, 2006 rdev->mode_info.output_csc_property, 2007 RADEON_OUTPUT_CSC_BYPASS); 2008 break; 2009 case DRM_MODE_CONNECTOR_DVII: 2010 case DRM_MODE_CONNECTOR_DVID: 2011 case DRM_MODE_CONNECTOR_HDMIA: 2012 case DRM_MODE_CONNECTOR_HDMIB: 2013 case DRM_MODE_CONNECTOR_DisplayPort: 2014 drm_connector_init(dev, &radeon_connector->base, 2015 &radeon_dp_connector_funcs, connector_type); 2016 drm_connector_helper_add(&radeon_connector->base, 2017 &radeon_dp_connector_helper_funcs); 2018 drm_object_attach_property(&radeon_connector->base.base, 2019 rdev->mode_info.underscan_property, 2020 UNDERSCAN_OFF); 2021 drm_object_attach_property(&radeon_connector->base.base, 2022 rdev->mode_info.underscan_hborder_property, 2023 0); 2024 drm_object_attach_property(&radeon_connector->base.base, 2025 rdev->mode_info.underscan_vborder_property, 2026 0); 2027 2028 drm_object_attach_property(&radeon_connector->base.base, 2029 dev->mode_config.scaling_mode_property, 2030 DRM_MODE_SCALE_NONE); 2031 2032 drm_object_attach_property(&radeon_connector->base.base, 2033 rdev->mode_info.dither_property, 2034 RADEON_FMT_DITHER_DISABLE); 2035 2036 if (radeon_audio != 0) { 2037 drm_object_attach_property(&radeon_connector->base.base, 2038 rdev->mode_info.audio_property, 2039 RADEON_AUDIO_AUTO); 2040 radeon_connector->audio = RADEON_AUDIO_AUTO; 2041 } 2042 if (ASIC_IS_DCE5(rdev)) 2043 drm_object_attach_property(&radeon_connector->base.base, 2044 rdev->mode_info.output_csc_property, 2045 RADEON_OUTPUT_CSC_BYPASS); 2046 2047 subpixel_order = SubPixelHorizontalRGB; 2048 connector->interlace_allowed = true; 2049 if (connector_type == DRM_MODE_CONNECTOR_HDMIB) 2050 connector->doublescan_allowed = true; 2051 else 2052 connector->doublescan_allowed = false; 2053 if (connector_type == DRM_MODE_CONNECTOR_DVII) { 2054 radeon_connector->dac_load_detect = true; 2055 drm_object_attach_property(&radeon_connector->base.base, 2056 rdev->mode_info.load_detect_property, 2057 1); 2058 } 2059 break; 2060 case DRM_MODE_CONNECTOR_LVDS: 2061 case DRM_MODE_CONNECTOR_eDP: 2062 drm_connector_init(dev, &radeon_connector->base, 2063 &radeon_lvds_bridge_connector_funcs, connector_type); 2064 drm_connector_helper_add(&radeon_connector->base, 2065 &radeon_dp_connector_helper_funcs); 2066 drm_object_attach_property(&radeon_connector->base.base, 2067 dev->mode_config.scaling_mode_property, 2068 DRM_MODE_SCALE_FULLSCREEN); 2069 subpixel_order = SubPixelHorizontalRGB; 2070 connector->interlace_allowed = false; 2071 connector->doublescan_allowed = false; 2072 break; 2073 } 2074 } else { 2075 switch (connector_type) { 2076 case DRM_MODE_CONNECTOR_VGA: 2077 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type); 2078 drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs); 2079 if (i2c_bus->valid) { 2080 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus); 2081 if (!radeon_connector->ddc_bus) 2082 DRM_ERROR("VGA: Failed to assign ddc bus! Check dmesg for i2c errors.\n"); 2083 } 2084 radeon_connector->dac_load_detect = true; 2085 drm_object_attach_property(&radeon_connector->base.base, 2086 rdev->mode_info.load_detect_property, 2087 1); 2088 if (ASIC_IS_AVIVO(rdev)) 2089 drm_object_attach_property(&radeon_connector->base.base, 2090 dev->mode_config.scaling_mode_property, 2091 DRM_MODE_SCALE_NONE); 2092 if (ASIC_IS_DCE5(rdev)) 2093 drm_object_attach_property(&radeon_connector->base.base, 2094 rdev->mode_info.output_csc_property, 2095 RADEON_OUTPUT_CSC_BYPASS); 2096 /* no HPD on analog connectors */ 2097 radeon_connector->hpd.hpd = RADEON_HPD_NONE; 2098 connector->interlace_allowed = true; 2099 connector->doublescan_allowed = true; 2100 break; 2101 case DRM_MODE_CONNECTOR_DVIA: 2102 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type); 2103 drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs); 2104 if (i2c_bus->valid) { 2105 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus); 2106 if (!radeon_connector->ddc_bus) 2107 DRM_ERROR("DVIA: Failed to assign ddc bus! Check dmesg for i2c errors.\n"); 2108 } 2109 radeon_connector->dac_load_detect = true; 2110 drm_object_attach_property(&radeon_connector->base.base, 2111 rdev->mode_info.load_detect_property, 2112 1); 2113 if (ASIC_IS_AVIVO(rdev)) 2114 drm_object_attach_property(&radeon_connector->base.base, 2115 dev->mode_config.scaling_mode_property, 2116 DRM_MODE_SCALE_NONE); 2117 if (ASIC_IS_DCE5(rdev)) 2118 drm_object_attach_property(&radeon_connector->base.base, 2119 rdev->mode_info.output_csc_property, 2120 RADEON_OUTPUT_CSC_BYPASS); 2121 /* no HPD on analog connectors */ 2122 radeon_connector->hpd.hpd = RADEON_HPD_NONE; 2123 connector->interlace_allowed = true; 2124 connector->doublescan_allowed = true; 2125 break; 2126 case DRM_MODE_CONNECTOR_DVII: 2127 case DRM_MODE_CONNECTOR_DVID: 2128 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL); 2129 if (!radeon_dig_connector) 2130 goto failed; 2131 radeon_dig_connector->igp_lane_info = igp_lane_info; 2132 radeon_connector->con_priv = radeon_dig_connector; 2133 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type); 2134 drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs); 2135 if (i2c_bus->valid) { 2136 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus); 2137 if (!radeon_connector->ddc_bus) 2138 DRM_ERROR("DVI: Failed to assign ddc bus! Check dmesg for i2c errors.\n"); 2139 } 2140 subpixel_order = SubPixelHorizontalRGB; 2141 drm_object_attach_property(&radeon_connector->base.base, 2142 rdev->mode_info.coherent_mode_property, 2143 1); 2144 if (ASIC_IS_AVIVO(rdev)) { 2145 drm_object_attach_property(&radeon_connector->base.base, 2146 rdev->mode_info.underscan_property, 2147 UNDERSCAN_OFF); 2148 drm_object_attach_property(&radeon_connector->base.base, 2149 rdev->mode_info.underscan_hborder_property, 2150 0); 2151 drm_object_attach_property(&radeon_connector->base.base, 2152 rdev->mode_info.underscan_vborder_property, 2153 0); 2154 drm_object_attach_property(&radeon_connector->base.base, 2155 rdev->mode_info.dither_property, 2156 RADEON_FMT_DITHER_DISABLE); 2157 drm_object_attach_property(&radeon_connector->base.base, 2158 dev->mode_config.scaling_mode_property, 2159 DRM_MODE_SCALE_NONE); 2160 } 2161 if (ASIC_IS_DCE2(rdev) && (radeon_audio != 0)) { 2162 drm_object_attach_property(&radeon_connector->base.base, 2163 rdev->mode_info.audio_property, 2164 RADEON_AUDIO_AUTO); 2165 radeon_connector->audio = RADEON_AUDIO_AUTO; 2166 } 2167 if (connector_type == DRM_MODE_CONNECTOR_DVII) { 2168 radeon_connector->dac_load_detect = true; 2169 drm_object_attach_property(&radeon_connector->base.base, 2170 rdev->mode_info.load_detect_property, 2171 1); 2172 } 2173 if (ASIC_IS_DCE5(rdev)) 2174 drm_object_attach_property(&radeon_connector->base.base, 2175 rdev->mode_info.output_csc_property, 2176 RADEON_OUTPUT_CSC_BYPASS); 2177 connector->interlace_allowed = true; 2178 if (connector_type == DRM_MODE_CONNECTOR_DVII) 2179 connector->doublescan_allowed = true; 2180 else 2181 connector->doublescan_allowed = false; 2182 break; 2183 case DRM_MODE_CONNECTOR_HDMIA: 2184 case DRM_MODE_CONNECTOR_HDMIB: 2185 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL); 2186 if (!radeon_dig_connector) 2187 goto failed; 2188 radeon_dig_connector->igp_lane_info = igp_lane_info; 2189 radeon_connector->con_priv = radeon_dig_connector; 2190 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type); 2191 drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs); 2192 if (i2c_bus->valid) { 2193 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus); 2194 if (!radeon_connector->ddc_bus) 2195 DRM_ERROR("HDMI: Failed to assign ddc bus! Check dmesg for i2c errors.\n"); 2196 } 2197 drm_object_attach_property(&radeon_connector->base.base, 2198 rdev->mode_info.coherent_mode_property, 2199 1); 2200 if (ASIC_IS_AVIVO(rdev)) { 2201 drm_object_attach_property(&radeon_connector->base.base, 2202 rdev->mode_info.underscan_property, 2203 UNDERSCAN_OFF); 2204 drm_object_attach_property(&radeon_connector->base.base, 2205 rdev->mode_info.underscan_hborder_property, 2206 0); 2207 drm_object_attach_property(&radeon_connector->base.base, 2208 rdev->mode_info.underscan_vborder_property, 2209 0); 2210 drm_object_attach_property(&radeon_connector->base.base, 2211 rdev->mode_info.dither_property, 2212 RADEON_FMT_DITHER_DISABLE); 2213 drm_object_attach_property(&radeon_connector->base.base, 2214 dev->mode_config.scaling_mode_property, 2215 DRM_MODE_SCALE_NONE); 2216 } 2217 if (ASIC_IS_DCE2(rdev) && (radeon_audio != 0)) { 2218 drm_object_attach_property(&radeon_connector->base.base, 2219 rdev->mode_info.audio_property, 2220 RADEON_AUDIO_AUTO); 2221 radeon_connector->audio = RADEON_AUDIO_AUTO; 2222 } 2223 if (ASIC_IS_DCE5(rdev)) 2224 drm_object_attach_property(&radeon_connector->base.base, 2225 rdev->mode_info.output_csc_property, 2226 RADEON_OUTPUT_CSC_BYPASS); 2227 subpixel_order = SubPixelHorizontalRGB; 2228 connector->interlace_allowed = true; 2229 if (connector_type == DRM_MODE_CONNECTOR_HDMIB) 2230 connector->doublescan_allowed = true; 2231 else 2232 connector->doublescan_allowed = false; 2233 break; 2234 case DRM_MODE_CONNECTOR_DisplayPort: 2235 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL); 2236 if (!radeon_dig_connector) 2237 goto failed; 2238 radeon_dig_connector->igp_lane_info = igp_lane_info; 2239 radeon_connector->con_priv = radeon_dig_connector; 2240 drm_connector_init(dev, &radeon_connector->base, &radeon_dp_connector_funcs, connector_type); 2241 drm_connector_helper_add(&radeon_connector->base, &radeon_dp_connector_helper_funcs); 2242 if (i2c_bus->valid) { 2243 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus); 2244 if (radeon_connector->ddc_bus) 2245 has_aux = true; 2246 else 2247 DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n"); 2248 } 2249 subpixel_order = SubPixelHorizontalRGB; 2250 drm_object_attach_property(&radeon_connector->base.base, 2251 rdev->mode_info.coherent_mode_property, 2252 1); 2253 if (ASIC_IS_AVIVO(rdev)) { 2254 drm_object_attach_property(&radeon_connector->base.base, 2255 rdev->mode_info.underscan_property, 2256 UNDERSCAN_OFF); 2257 drm_object_attach_property(&radeon_connector->base.base, 2258 rdev->mode_info.underscan_hborder_property, 2259 0); 2260 drm_object_attach_property(&radeon_connector->base.base, 2261 rdev->mode_info.underscan_vborder_property, 2262 0); 2263 drm_object_attach_property(&radeon_connector->base.base, 2264 rdev->mode_info.dither_property, 2265 RADEON_FMT_DITHER_DISABLE); 2266 drm_object_attach_property(&radeon_connector->base.base, 2267 dev->mode_config.scaling_mode_property, 2268 DRM_MODE_SCALE_NONE); 2269 } 2270 if (ASIC_IS_DCE2(rdev) && (radeon_audio != 0)) { 2271 drm_object_attach_property(&radeon_connector->base.base, 2272 rdev->mode_info.audio_property, 2273 RADEON_AUDIO_AUTO); 2274 radeon_connector->audio = RADEON_AUDIO_AUTO; 2275 } 2276 if (ASIC_IS_DCE5(rdev)) 2277 drm_object_attach_property(&radeon_connector->base.base, 2278 rdev->mode_info.output_csc_property, 2279 RADEON_OUTPUT_CSC_BYPASS); 2280 connector->interlace_allowed = true; 2281 /* in theory with a DP to VGA converter... */ 2282 connector->doublescan_allowed = false; 2283 break; 2284 case DRM_MODE_CONNECTOR_eDP: 2285 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL); 2286 if (!radeon_dig_connector) 2287 goto failed; 2288 radeon_dig_connector->igp_lane_info = igp_lane_info; 2289 radeon_connector->con_priv = radeon_dig_connector; 2290 drm_connector_init(dev, &radeon_connector->base, &radeon_edp_connector_funcs, connector_type); 2291 drm_connector_helper_add(&radeon_connector->base, &radeon_dp_connector_helper_funcs); 2292 if (i2c_bus->valid) { 2293 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus); 2294 if (radeon_connector->ddc_bus) 2295 has_aux = true; 2296 else 2297 DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n"); 2298 } 2299 drm_object_attach_property(&radeon_connector->base.base, 2300 dev->mode_config.scaling_mode_property, 2301 DRM_MODE_SCALE_FULLSCREEN); 2302 subpixel_order = SubPixelHorizontalRGB; 2303 connector->interlace_allowed = false; 2304 connector->doublescan_allowed = false; 2305 break; 2306 case DRM_MODE_CONNECTOR_SVIDEO: 2307 case DRM_MODE_CONNECTOR_Composite: 2308 case DRM_MODE_CONNECTOR_9PinDIN: 2309 drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type); 2310 drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs); 2311 radeon_connector->dac_load_detect = true; 2312 drm_object_attach_property(&radeon_connector->base.base, 2313 rdev->mode_info.load_detect_property, 2314 1); 2315 drm_object_attach_property(&radeon_connector->base.base, 2316 rdev->mode_info.tv_std_property, 2317 radeon_atombios_get_tv_info(rdev)); 2318 /* no HPD on analog connectors */ 2319 radeon_connector->hpd.hpd = RADEON_HPD_NONE; 2320 connector->interlace_allowed = false; 2321 connector->doublescan_allowed = false; 2322 break; 2323 case DRM_MODE_CONNECTOR_LVDS: 2324 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL); 2325 if (!radeon_dig_connector) 2326 goto failed; 2327 radeon_dig_connector->igp_lane_info = igp_lane_info; 2328 radeon_connector->con_priv = radeon_dig_connector; 2329 drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type); 2330 drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs); 2331 if (i2c_bus->valid) { 2332 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus); 2333 if (!radeon_connector->ddc_bus) 2334 DRM_ERROR("LVDS: Failed to assign ddc bus! Check dmesg for i2c errors.\n"); 2335 } 2336 drm_object_attach_property(&radeon_connector->base.base, 2337 dev->mode_config.scaling_mode_property, 2338 DRM_MODE_SCALE_FULLSCREEN); 2339 subpixel_order = SubPixelHorizontalRGB; 2340 connector->interlace_allowed = false; 2341 connector->doublescan_allowed = false; 2342 break; 2343 } 2344 } 2345 2346 if (radeon_connector->hpd.hpd == RADEON_HPD_NONE) { 2347 if (i2c_bus->valid) { 2348 connector->polled = DRM_CONNECTOR_POLL_CONNECT | 2349 DRM_CONNECTOR_POLL_DISCONNECT; 2350 } 2351 } else 2352 connector->polled = DRM_CONNECTOR_POLL_HPD; 2353 2354 connector->display_info.subpixel_order = subpixel_order; 2355 drm_connector_register(connector); 2356 2357 if (has_aux) 2358 radeon_dp_aux_init(radeon_connector); 2359 2360 return; 2361 2362 failed: 2363 drm_connector_cleanup(connector); 2364 kfree(connector); 2365 } 2366 2367 void 2368 radeon_add_legacy_connector(struct drm_device *dev, 2369 uint32_t connector_id, 2370 uint32_t supported_device, 2371 int connector_type, 2372 struct radeon_i2c_bus_rec *i2c_bus, 2373 uint16_t connector_object_id, 2374 struct radeon_hpd *hpd) 2375 { 2376 struct radeon_device *rdev = dev->dev_private; 2377 struct drm_connector *connector; 2378 struct radeon_connector *radeon_connector; 2379 uint32_t subpixel_order = SubPixelNone; 2380 2381 if (connector_type == DRM_MODE_CONNECTOR_Unknown) 2382 return; 2383 2384 /* if the user selected tv=0 don't try and add the connector */ 2385 if (((connector_type == DRM_MODE_CONNECTOR_SVIDEO) || 2386 (connector_type == DRM_MODE_CONNECTOR_Composite) || 2387 (connector_type == DRM_MODE_CONNECTOR_9PinDIN)) && 2388 (radeon_tv == 0)) 2389 return; 2390 2391 /* see if we already added it */ 2392 list_for_each_entry(connector, &dev->mode_config.connector_list, head) { 2393 radeon_connector = to_radeon_connector(connector); 2394 if (radeon_connector->connector_id == connector_id) { 2395 radeon_connector->devices |= supported_device; 2396 return; 2397 } 2398 } 2399 2400 radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL); 2401 if (!radeon_connector) 2402 return; 2403 2404 connector = &radeon_connector->base; 2405 2406 radeon_connector->connector_id = connector_id; 2407 radeon_connector->devices = supported_device; 2408 radeon_connector->connector_object_id = connector_object_id; 2409 radeon_connector->hpd = *hpd; 2410 2411 switch (connector_type) { 2412 case DRM_MODE_CONNECTOR_VGA: 2413 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type); 2414 drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs); 2415 if (i2c_bus->valid) { 2416 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus); 2417 if (!radeon_connector->ddc_bus) 2418 DRM_ERROR("VGA: Failed to assign ddc bus! Check dmesg for i2c errors.\n"); 2419 } 2420 radeon_connector->dac_load_detect = true; 2421 drm_object_attach_property(&radeon_connector->base.base, 2422 rdev->mode_info.load_detect_property, 2423 1); 2424 /* no HPD on analog connectors */ 2425 radeon_connector->hpd.hpd = RADEON_HPD_NONE; 2426 connector->interlace_allowed = true; 2427 connector->doublescan_allowed = true; 2428 break; 2429 case DRM_MODE_CONNECTOR_DVIA: 2430 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type); 2431 drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs); 2432 if (i2c_bus->valid) { 2433 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus); 2434 if (!radeon_connector->ddc_bus) 2435 DRM_ERROR("DVIA: Failed to assign ddc bus! Check dmesg for i2c errors.\n"); 2436 } 2437 radeon_connector->dac_load_detect = true; 2438 drm_object_attach_property(&radeon_connector->base.base, 2439 rdev->mode_info.load_detect_property, 2440 1); 2441 /* no HPD on analog connectors */ 2442 radeon_connector->hpd.hpd = RADEON_HPD_NONE; 2443 connector->interlace_allowed = true; 2444 connector->doublescan_allowed = true; 2445 break; 2446 case DRM_MODE_CONNECTOR_DVII: 2447 case DRM_MODE_CONNECTOR_DVID: 2448 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type); 2449 drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs); 2450 if (i2c_bus->valid) { 2451 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus); 2452 if (!radeon_connector->ddc_bus) 2453 DRM_ERROR("DVI: Failed to assign ddc bus! Check dmesg for i2c errors.\n"); 2454 } 2455 if (connector_type == DRM_MODE_CONNECTOR_DVII) { 2456 radeon_connector->dac_load_detect = true; 2457 drm_object_attach_property(&radeon_connector->base.base, 2458 rdev->mode_info.load_detect_property, 2459 1); 2460 } 2461 subpixel_order = SubPixelHorizontalRGB; 2462 connector->interlace_allowed = true; 2463 if (connector_type == DRM_MODE_CONNECTOR_DVII) 2464 connector->doublescan_allowed = true; 2465 else 2466 connector->doublescan_allowed = false; 2467 break; 2468 case DRM_MODE_CONNECTOR_SVIDEO: 2469 case DRM_MODE_CONNECTOR_Composite: 2470 case DRM_MODE_CONNECTOR_9PinDIN: 2471 drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type); 2472 drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs); 2473 radeon_connector->dac_load_detect = true; 2474 /* RS400,RC410,RS480 chipset seems to report a lot 2475 * of false positive on load detect, we haven't yet 2476 * found a way to make load detect reliable on those 2477 * chipset, thus just disable it for TV. 2478 */ 2479 if (rdev->family == CHIP_RS400 || rdev->family == CHIP_RS480) 2480 radeon_connector->dac_load_detect = false; 2481 drm_object_attach_property(&radeon_connector->base.base, 2482 rdev->mode_info.load_detect_property, 2483 radeon_connector->dac_load_detect); 2484 drm_object_attach_property(&radeon_connector->base.base, 2485 rdev->mode_info.tv_std_property, 2486 radeon_combios_get_tv_info(rdev)); 2487 /* no HPD on analog connectors */ 2488 radeon_connector->hpd.hpd = RADEON_HPD_NONE; 2489 connector->interlace_allowed = false; 2490 connector->doublescan_allowed = false; 2491 break; 2492 case DRM_MODE_CONNECTOR_LVDS: 2493 drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type); 2494 drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs); 2495 if (i2c_bus->valid) { 2496 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus); 2497 if (!radeon_connector->ddc_bus) 2498 DRM_ERROR("LVDS: Failed to assign ddc bus! Check dmesg for i2c errors.\n"); 2499 } 2500 drm_object_attach_property(&radeon_connector->base.base, 2501 dev->mode_config.scaling_mode_property, 2502 DRM_MODE_SCALE_FULLSCREEN); 2503 subpixel_order = SubPixelHorizontalRGB; 2504 connector->interlace_allowed = false; 2505 connector->doublescan_allowed = false; 2506 break; 2507 } 2508 2509 if (radeon_connector->hpd.hpd == RADEON_HPD_NONE) { 2510 if (i2c_bus->valid) { 2511 connector->polled = DRM_CONNECTOR_POLL_CONNECT | 2512 DRM_CONNECTOR_POLL_DISCONNECT; 2513 } 2514 } else 2515 connector->polled = DRM_CONNECTOR_POLL_HPD; 2516 2517 connector->display_info.subpixel_order = subpixel_order; 2518 drm_connector_register(connector); 2519 } 2520 2521 void radeon_setup_mst_connector(struct drm_device *dev) 2522 { 2523 struct radeon_device *rdev = dev->dev_private; 2524 struct drm_connector *connector; 2525 struct radeon_connector *radeon_connector; 2526 2527 if (!ASIC_IS_DCE5(rdev)) 2528 return; 2529 2530 if (radeon_mst == 0) 2531 return; 2532 2533 list_for_each_entry(connector, &dev->mode_config.connector_list, head) { 2534 int ret; 2535 2536 radeon_connector = to_radeon_connector(connector); 2537 2538 if (connector->connector_type != DRM_MODE_CONNECTOR_DisplayPort) 2539 continue; 2540 2541 ret = radeon_dp_mst_init(radeon_connector); 2542 } 2543 } 2544