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