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