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