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