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