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