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