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