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