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 "drmP.h" 27 #include "drm_edid.h" 28 #include "drm_crtc_helper.h" 29 #include "drm_fb_helper.h" 30 #include "radeon_drm.h" 31 #include "radeon.h" 32 #include "atom.h" 33 34 extern void 35 radeon_combios_connected_scratch_regs(struct drm_connector *connector, 36 struct drm_encoder *encoder, 37 bool connected); 38 extern void 39 radeon_atombios_connected_scratch_regs(struct drm_connector *connector, 40 struct drm_encoder *encoder, 41 bool connected); 42 43 extern void 44 radeon_legacy_backlight_init(struct radeon_encoder *radeon_encoder, 45 struct drm_connector *drm_connector); 46 47 void radeon_connector_hotplug(struct drm_connector *connector) 48 { 49 struct drm_device *dev = connector->dev; 50 struct radeon_device *rdev = dev->dev_private; 51 struct radeon_connector *radeon_connector = to_radeon_connector(connector); 52 53 if (radeon_connector->hpd.hpd != RADEON_HPD_NONE) 54 radeon_hpd_set_polarity(rdev, radeon_connector->hpd.hpd); 55 56 if ((connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort) || 57 (connector->connector_type == DRM_MODE_CONNECTOR_eDP)) { 58 if ((radeon_dp_getsinktype(radeon_connector) == CONNECTOR_OBJECT_ID_DISPLAYPORT) || 59 (radeon_dp_getsinktype(radeon_connector) == CONNECTOR_OBJECT_ID_eDP)) { 60 if (radeon_dp_needs_link_train(radeon_connector)) { 61 if (connector->encoder) 62 dp_link_train(connector->encoder, connector); 63 } 64 } 65 } 66 67 } 68 69 static void radeon_property_change_mode(struct drm_encoder *encoder) 70 { 71 struct drm_crtc *crtc = encoder->crtc; 72 73 if (crtc && crtc->enabled) { 74 drm_crtc_helper_set_mode(crtc, &crtc->mode, 75 crtc->x, crtc->y, crtc->fb); 76 } 77 } 78 static void 79 radeon_connector_update_scratch_regs(struct drm_connector *connector, enum drm_connector_status status) 80 { 81 struct drm_device *dev = connector->dev; 82 struct radeon_device *rdev = dev->dev_private; 83 struct drm_encoder *best_encoder = NULL; 84 struct drm_encoder *encoder = NULL; 85 struct drm_connector_helper_funcs *connector_funcs = connector->helper_private; 86 struct drm_mode_object *obj; 87 bool connected; 88 int i; 89 90 best_encoder = connector_funcs->best_encoder(connector); 91 92 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) { 93 if (connector->encoder_ids[i] == 0) 94 break; 95 96 obj = drm_mode_object_find(connector->dev, 97 connector->encoder_ids[i], 98 DRM_MODE_OBJECT_ENCODER); 99 if (!obj) 100 continue; 101 102 encoder = obj_to_encoder(obj); 103 104 if ((encoder == best_encoder) && (status == connector_status_connected)) 105 connected = true; 106 else 107 connected = false; 108 109 if (rdev->is_atom_bios) 110 radeon_atombios_connected_scratch_regs(connector, encoder, connected); 111 else 112 radeon_combios_connected_scratch_regs(connector, encoder, connected); 113 114 } 115 } 116 117 struct drm_encoder *radeon_find_encoder(struct drm_connector *connector, int encoder_type) 118 { 119 struct drm_mode_object *obj; 120 struct drm_encoder *encoder; 121 int i; 122 123 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) { 124 if (connector->encoder_ids[i] == 0) 125 break; 126 127 obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER); 128 if (!obj) 129 continue; 130 131 encoder = obj_to_encoder(obj); 132 if (encoder->encoder_type == encoder_type) 133 return encoder; 134 } 135 return NULL; 136 } 137 138 struct drm_encoder *radeon_best_single_encoder(struct drm_connector *connector) 139 { 140 int enc_id = connector->encoder_ids[0]; 141 struct drm_mode_object *obj; 142 struct drm_encoder *encoder; 143 144 /* pick the encoder ids */ 145 if (enc_id) { 146 obj = drm_mode_object_find(connector->dev, enc_id, DRM_MODE_OBJECT_ENCODER); 147 if (!obj) 148 return NULL; 149 encoder = obj_to_encoder(obj); 150 return encoder; 151 } 152 return NULL; 153 } 154 155 /* 156 * radeon_connector_analog_encoder_conflict_solve 157 * - search for other connectors sharing this encoder 158 * if priority is true, then set them disconnected if this is connected 159 * if priority is false, set us disconnected if they are connected 160 */ 161 static enum drm_connector_status 162 radeon_connector_analog_encoder_conflict_solve(struct drm_connector *connector, 163 struct drm_encoder *encoder, 164 enum drm_connector_status current_status, 165 bool priority) 166 { 167 struct drm_device *dev = connector->dev; 168 struct drm_connector *conflict; 169 struct radeon_connector *radeon_conflict; 170 int i; 171 172 list_for_each_entry(conflict, &dev->mode_config.connector_list, head) { 173 if (conflict == connector) 174 continue; 175 176 radeon_conflict = to_radeon_connector(conflict); 177 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) { 178 if (conflict->encoder_ids[i] == 0) 179 break; 180 181 /* if the IDs match */ 182 if (conflict->encoder_ids[i] == encoder->base.id) { 183 if (conflict->status != connector_status_connected) 184 continue; 185 186 if (radeon_conflict->use_digital) 187 continue; 188 189 if (priority == true) { 190 DRM_DEBUG_KMS("1: conflicting encoders switching off %s\n", drm_get_connector_name(conflict)); 191 DRM_DEBUG_KMS("in favor of %s\n", drm_get_connector_name(connector)); 192 conflict->status = connector_status_disconnected; 193 radeon_connector_update_scratch_regs(conflict, connector_status_disconnected); 194 } else { 195 DRM_DEBUG_KMS("2: conflicting encoders switching off %s\n", drm_get_connector_name(connector)); 196 DRM_DEBUG_KMS("in favor of %s\n", drm_get_connector_name(conflict)); 197 current_status = connector_status_disconnected; 198 } 199 break; 200 } 201 } 202 } 203 return current_status; 204 205 } 206 207 static struct drm_display_mode *radeon_fp_native_mode(struct drm_encoder *encoder) 208 { 209 struct drm_device *dev = encoder->dev; 210 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder); 211 struct drm_display_mode *mode = NULL; 212 struct drm_display_mode *native_mode = &radeon_encoder->native_mode; 213 214 if (native_mode->hdisplay != 0 && 215 native_mode->vdisplay != 0 && 216 native_mode->clock != 0) { 217 mode = drm_mode_duplicate(dev, native_mode); 218 mode->type = DRM_MODE_TYPE_PREFERRED | DRM_MODE_TYPE_DRIVER; 219 drm_mode_set_name(mode); 220 221 DRM_DEBUG_KMS("Adding native panel mode %s\n", mode->name); 222 } else if (native_mode->hdisplay != 0 && 223 native_mode->vdisplay != 0) { 224 /* mac laptops without an edid */ 225 /* Note that this is not necessarily the exact panel mode, 226 * but an approximation based on the cvt formula. For these 227 * systems we should ideally read the mode info out of the 228 * registers or add a mode table, but this works and is much 229 * simpler. 230 */ 231 mode = drm_cvt_mode(dev, native_mode->hdisplay, native_mode->vdisplay, 60, true, false, false); 232 mode->type = DRM_MODE_TYPE_PREFERRED | DRM_MODE_TYPE_DRIVER; 233 DRM_DEBUG_KMS("Adding cvt approximation of native panel mode %s\n", mode->name); 234 } 235 return mode; 236 } 237 238 static void radeon_add_common_modes(struct drm_encoder *encoder, struct drm_connector *connector) 239 { 240 struct drm_device *dev = encoder->dev; 241 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder); 242 struct drm_display_mode *mode = NULL; 243 struct drm_display_mode *native_mode = &radeon_encoder->native_mode; 244 int i; 245 struct mode_size { 246 int w; 247 int h; 248 } common_modes[17] = { 249 { 640, 480}, 250 { 720, 480}, 251 { 800, 600}, 252 { 848, 480}, 253 {1024, 768}, 254 {1152, 768}, 255 {1280, 720}, 256 {1280, 800}, 257 {1280, 854}, 258 {1280, 960}, 259 {1280, 1024}, 260 {1440, 900}, 261 {1400, 1050}, 262 {1680, 1050}, 263 {1600, 1200}, 264 {1920, 1080}, 265 {1920, 1200} 266 }; 267 268 for (i = 0; i < 17; i++) { 269 if (radeon_encoder->devices & (ATOM_DEVICE_TV_SUPPORT)) { 270 if (common_modes[i].w > 1024 || 271 common_modes[i].h > 768) 272 continue; 273 } 274 if (radeon_encoder->devices & (ATOM_DEVICE_LCD_SUPPORT)) { 275 if (common_modes[i].w > native_mode->hdisplay || 276 common_modes[i].h > native_mode->vdisplay || 277 (common_modes[i].w == native_mode->hdisplay && 278 common_modes[i].h == native_mode->vdisplay)) 279 continue; 280 } 281 if (common_modes[i].w < 320 || common_modes[i].h < 200) 282 continue; 283 284 mode = drm_cvt_mode(dev, common_modes[i].w, common_modes[i].h, 60, false, false, false); 285 drm_mode_probed_add(connector, mode); 286 } 287 } 288 289 int radeon_connector_set_property(struct drm_connector *connector, struct drm_property *property, 290 uint64_t val) 291 { 292 struct drm_device *dev = connector->dev; 293 struct radeon_device *rdev = dev->dev_private; 294 struct drm_encoder *encoder; 295 struct radeon_encoder *radeon_encoder; 296 297 if (property == rdev->mode_info.coherent_mode_property) { 298 struct radeon_encoder_atom_dig *dig; 299 bool new_coherent_mode; 300 301 /* need to find digital encoder on connector */ 302 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS); 303 if (!encoder) 304 return 0; 305 306 radeon_encoder = to_radeon_encoder(encoder); 307 308 if (!radeon_encoder->enc_priv) 309 return 0; 310 311 dig = radeon_encoder->enc_priv; 312 new_coherent_mode = val ? true : false; 313 if (dig->coherent_mode != new_coherent_mode) { 314 dig->coherent_mode = new_coherent_mode; 315 radeon_property_change_mode(&radeon_encoder->base); 316 } 317 } 318 319 if (property == rdev->mode_info.underscan_property) { 320 /* need to find digital encoder on connector */ 321 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS); 322 if (!encoder) 323 return 0; 324 325 radeon_encoder = to_radeon_encoder(encoder); 326 327 if (radeon_encoder->underscan_type != val) { 328 radeon_encoder->underscan_type = val; 329 radeon_property_change_mode(&radeon_encoder->base); 330 } 331 } 332 333 if (property == rdev->mode_info.underscan_hborder_property) { 334 /* need to find digital encoder on connector */ 335 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS); 336 if (!encoder) 337 return 0; 338 339 radeon_encoder = to_radeon_encoder(encoder); 340 341 if (radeon_encoder->underscan_hborder != val) { 342 radeon_encoder->underscan_hborder = val; 343 radeon_property_change_mode(&radeon_encoder->base); 344 } 345 } 346 347 if (property == rdev->mode_info.underscan_vborder_property) { 348 /* need to find digital encoder on connector */ 349 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS); 350 if (!encoder) 351 return 0; 352 353 radeon_encoder = to_radeon_encoder(encoder); 354 355 if (radeon_encoder->underscan_vborder != val) { 356 radeon_encoder->underscan_vborder = val; 357 radeon_property_change_mode(&radeon_encoder->base); 358 } 359 } 360 361 if (property == rdev->mode_info.tv_std_property) { 362 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TVDAC); 363 if (!encoder) { 364 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_DAC); 365 } 366 367 if (!encoder) 368 return 0; 369 370 radeon_encoder = to_radeon_encoder(encoder); 371 if (!radeon_encoder->enc_priv) 372 return 0; 373 if (ASIC_IS_AVIVO(rdev) || radeon_r4xx_atom) { 374 struct radeon_encoder_atom_dac *dac_int; 375 dac_int = radeon_encoder->enc_priv; 376 dac_int->tv_std = val; 377 } else { 378 struct radeon_encoder_tv_dac *dac_int; 379 dac_int = radeon_encoder->enc_priv; 380 dac_int->tv_std = val; 381 } 382 radeon_property_change_mode(&radeon_encoder->base); 383 } 384 385 if (property == rdev->mode_info.load_detect_property) { 386 struct radeon_connector *radeon_connector = 387 to_radeon_connector(connector); 388 389 if (val == 0) 390 radeon_connector->dac_load_detect = false; 391 else 392 radeon_connector->dac_load_detect = true; 393 } 394 395 if (property == rdev->mode_info.tmds_pll_property) { 396 struct radeon_encoder_int_tmds *tmds = NULL; 397 bool ret = false; 398 /* need to find digital encoder on connector */ 399 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS); 400 if (!encoder) 401 return 0; 402 403 radeon_encoder = to_radeon_encoder(encoder); 404 405 tmds = radeon_encoder->enc_priv; 406 if (!tmds) 407 return 0; 408 409 if (val == 0) { 410 if (rdev->is_atom_bios) 411 ret = radeon_atombios_get_tmds_info(radeon_encoder, tmds); 412 else 413 ret = radeon_legacy_get_tmds_info_from_combios(radeon_encoder, tmds); 414 } 415 if (val == 1 || ret == false) { 416 radeon_legacy_get_tmds_info_from_table(radeon_encoder, tmds); 417 } 418 radeon_property_change_mode(&radeon_encoder->base); 419 } 420 421 return 0; 422 } 423 424 static void radeon_fixup_lvds_native_mode(struct drm_encoder *encoder, 425 struct drm_connector *connector) 426 { 427 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder); 428 struct drm_display_mode *native_mode = &radeon_encoder->native_mode; 429 430 /* Try to get native mode details from EDID if necessary */ 431 if (!native_mode->clock) { 432 struct drm_display_mode *t, *mode; 433 434 list_for_each_entry_safe(mode, t, &connector->probed_modes, head) { 435 if (mode->hdisplay == native_mode->hdisplay && 436 mode->vdisplay == native_mode->vdisplay) { 437 *native_mode = *mode; 438 drm_mode_set_crtcinfo(native_mode, CRTC_INTERLACE_HALVE_V); 439 DRM_DEBUG_KMS("Determined LVDS native mode details from EDID\n"); 440 break; 441 } 442 } 443 } 444 if (!native_mode->clock) { 445 DRM_DEBUG_KMS("No LVDS native mode details, disabling RMX\n"); 446 radeon_encoder->rmx_type = RMX_OFF; 447 } 448 } 449 450 static int radeon_lvds_get_modes(struct drm_connector *connector) 451 { 452 struct radeon_connector *radeon_connector = to_radeon_connector(connector); 453 struct drm_encoder *encoder; 454 int ret = 0; 455 struct drm_display_mode *mode; 456 457 if (radeon_connector->ddc_bus) { 458 ret = radeon_ddc_get_modes(radeon_connector); 459 if (ret > 0) { 460 encoder = radeon_best_single_encoder(connector); 461 if (encoder) { 462 radeon_fixup_lvds_native_mode(encoder, connector); 463 /* add scaled modes */ 464 radeon_add_common_modes(encoder, connector); 465 } 466 return ret; 467 } 468 } 469 470 encoder = radeon_best_single_encoder(connector); 471 if (!encoder) 472 return 0; 473 474 /* we have no EDID modes */ 475 mode = radeon_fp_native_mode(encoder); 476 if (mode) { 477 ret = 1; 478 drm_mode_probed_add(connector, mode); 479 /* add the width/height from vbios tables if available */ 480 connector->display_info.width_mm = mode->width_mm; 481 connector->display_info.height_mm = mode->height_mm; 482 /* add scaled modes */ 483 radeon_add_common_modes(encoder, connector); 484 } 485 486 return ret; 487 } 488 489 static int radeon_lvds_mode_valid(struct drm_connector *connector, 490 struct drm_display_mode *mode) 491 { 492 struct drm_encoder *encoder = radeon_best_single_encoder(connector); 493 494 if ((mode->hdisplay < 320) || (mode->vdisplay < 240)) 495 return MODE_PANEL; 496 497 if (encoder) { 498 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder); 499 struct drm_display_mode *native_mode = &radeon_encoder->native_mode; 500 501 /* AVIVO hardware supports downscaling modes larger than the panel 502 * to the panel size, but I'm not sure this is desirable. 503 */ 504 if ((mode->hdisplay > native_mode->hdisplay) || 505 (mode->vdisplay > native_mode->vdisplay)) 506 return MODE_PANEL; 507 508 /* if scaling is disabled, block non-native modes */ 509 if (radeon_encoder->rmx_type == RMX_OFF) { 510 if ((mode->hdisplay != native_mode->hdisplay) || 511 (mode->vdisplay != native_mode->vdisplay)) 512 return MODE_PANEL; 513 } 514 } 515 516 return MODE_OK; 517 } 518 519 static enum drm_connector_status 520 radeon_lvds_detect(struct drm_connector *connector, bool force) 521 { 522 struct radeon_connector *radeon_connector = to_radeon_connector(connector); 523 struct drm_encoder *encoder = radeon_best_single_encoder(connector); 524 enum drm_connector_status ret = connector_status_disconnected; 525 526 if (encoder) { 527 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder); 528 struct drm_display_mode *native_mode = &radeon_encoder->native_mode; 529 530 /* check if panel is valid */ 531 if (native_mode->hdisplay >= 320 && native_mode->vdisplay >= 240) 532 ret = connector_status_connected; 533 534 } 535 536 /* check for edid as well */ 537 if (radeon_connector->edid) 538 ret = connector_status_connected; 539 else { 540 if (radeon_connector->ddc_bus) { 541 radeon_connector->edid = drm_get_edid(&radeon_connector->base, 542 &radeon_connector->ddc_bus->adapter); 543 if (radeon_connector->edid) 544 ret = connector_status_connected; 545 } 546 } 547 /* check acpi lid status ??? */ 548 549 radeon_connector_update_scratch_regs(connector, ret); 550 return ret; 551 } 552 553 static void radeon_connector_destroy(struct drm_connector *connector) 554 { 555 struct radeon_connector *radeon_connector = to_radeon_connector(connector); 556 557 if (radeon_connector->edid) 558 kfree(radeon_connector->edid); 559 kfree(radeon_connector->con_priv); 560 drm_sysfs_connector_remove(connector); 561 drm_connector_cleanup(connector); 562 kfree(connector); 563 } 564 565 static int radeon_lvds_set_property(struct drm_connector *connector, 566 struct drm_property *property, 567 uint64_t value) 568 { 569 struct drm_device *dev = connector->dev; 570 struct radeon_encoder *radeon_encoder; 571 enum radeon_rmx_type rmx_type; 572 573 DRM_DEBUG_KMS("\n"); 574 if (property != dev->mode_config.scaling_mode_property) 575 return 0; 576 577 if (connector->encoder) 578 radeon_encoder = to_radeon_encoder(connector->encoder); 579 else { 580 struct drm_connector_helper_funcs *connector_funcs = connector->helper_private; 581 radeon_encoder = to_radeon_encoder(connector_funcs->best_encoder(connector)); 582 } 583 584 switch (value) { 585 case DRM_MODE_SCALE_NONE: rmx_type = RMX_OFF; break; 586 case DRM_MODE_SCALE_CENTER: rmx_type = RMX_CENTER; break; 587 case DRM_MODE_SCALE_ASPECT: rmx_type = RMX_ASPECT; break; 588 default: 589 case DRM_MODE_SCALE_FULLSCREEN: rmx_type = RMX_FULL; break; 590 } 591 if (radeon_encoder->rmx_type == rmx_type) 592 return 0; 593 594 radeon_encoder->rmx_type = rmx_type; 595 596 radeon_property_change_mode(&radeon_encoder->base); 597 return 0; 598 } 599 600 601 struct drm_connector_helper_funcs radeon_lvds_connector_helper_funcs = { 602 .get_modes = radeon_lvds_get_modes, 603 .mode_valid = radeon_lvds_mode_valid, 604 .best_encoder = radeon_best_single_encoder, 605 }; 606 607 struct drm_connector_funcs radeon_lvds_connector_funcs = { 608 .dpms = drm_helper_connector_dpms, 609 .detect = radeon_lvds_detect, 610 .fill_modes = drm_helper_probe_single_connector_modes, 611 .destroy = radeon_connector_destroy, 612 .set_property = radeon_lvds_set_property, 613 }; 614 615 static int radeon_vga_get_modes(struct drm_connector *connector) 616 { 617 struct radeon_connector *radeon_connector = to_radeon_connector(connector); 618 int ret; 619 620 ret = radeon_ddc_get_modes(radeon_connector); 621 622 return ret; 623 } 624 625 static int radeon_vga_mode_valid(struct drm_connector *connector, 626 struct drm_display_mode *mode) 627 { 628 /* XXX check mode bandwidth */ 629 /* XXX verify against max DAC output frequency */ 630 return MODE_OK; 631 } 632 633 static enum drm_connector_status 634 radeon_vga_detect(struct drm_connector *connector, bool force) 635 { 636 struct radeon_connector *radeon_connector = to_radeon_connector(connector); 637 struct drm_encoder *encoder; 638 struct drm_encoder_helper_funcs *encoder_funcs; 639 bool dret = false; 640 enum drm_connector_status ret = connector_status_disconnected; 641 642 encoder = radeon_best_single_encoder(connector); 643 if (!encoder) 644 ret = connector_status_disconnected; 645 646 if (radeon_connector->ddc_bus) 647 dret = radeon_ddc_probe(radeon_connector); 648 if (dret) { 649 if (radeon_connector->edid) { 650 kfree(radeon_connector->edid); 651 radeon_connector->edid = NULL; 652 } 653 radeon_connector->edid = drm_get_edid(&radeon_connector->base, &radeon_connector->ddc_bus->adapter); 654 655 if (!radeon_connector->edid) { 656 DRM_ERROR("%s: probed a monitor but no|invalid EDID\n", 657 drm_get_connector_name(connector)); 658 ret = connector_status_connected; 659 } else { 660 radeon_connector->use_digital = !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL); 661 662 /* some oems have boards with separate digital and analog connectors 663 * with a shared ddc line (often vga + hdmi) 664 */ 665 if (radeon_connector->use_digital && radeon_connector->shared_ddc) { 666 kfree(radeon_connector->edid); 667 radeon_connector->edid = NULL; 668 ret = connector_status_disconnected; 669 } else 670 ret = connector_status_connected; 671 } 672 } else { 673 674 /* if we aren't forcing don't do destructive polling */ 675 if (!force) 676 return connector->status; 677 678 if (radeon_connector->dac_load_detect && encoder) { 679 encoder_funcs = encoder->helper_private; 680 ret = encoder_funcs->detect(encoder, connector); 681 } 682 } 683 684 if (ret == connector_status_connected) 685 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true); 686 radeon_connector_update_scratch_regs(connector, ret); 687 return ret; 688 } 689 690 struct drm_connector_helper_funcs radeon_vga_connector_helper_funcs = { 691 .get_modes = radeon_vga_get_modes, 692 .mode_valid = radeon_vga_mode_valid, 693 .best_encoder = radeon_best_single_encoder, 694 }; 695 696 struct drm_connector_funcs radeon_vga_connector_funcs = { 697 .dpms = drm_helper_connector_dpms, 698 .detect = radeon_vga_detect, 699 .fill_modes = drm_helper_probe_single_connector_modes, 700 .destroy = radeon_connector_destroy, 701 .set_property = radeon_connector_set_property, 702 }; 703 704 static int radeon_tv_get_modes(struct drm_connector *connector) 705 { 706 struct drm_device *dev = connector->dev; 707 struct radeon_device *rdev = dev->dev_private; 708 struct drm_display_mode *tv_mode; 709 struct drm_encoder *encoder; 710 711 encoder = radeon_best_single_encoder(connector); 712 if (!encoder) 713 return 0; 714 715 /* avivo chips can scale any mode */ 716 if (rdev->family >= CHIP_RS600) 717 /* add scaled modes */ 718 radeon_add_common_modes(encoder, connector); 719 else { 720 /* only 800x600 is supported right now on pre-avivo chips */ 721 tv_mode = drm_cvt_mode(dev, 800, 600, 60, false, false, false); 722 tv_mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED; 723 drm_mode_probed_add(connector, tv_mode); 724 } 725 return 1; 726 } 727 728 static int radeon_tv_mode_valid(struct drm_connector *connector, 729 struct drm_display_mode *mode) 730 { 731 if ((mode->hdisplay > 1024) || (mode->vdisplay > 768)) 732 return MODE_CLOCK_RANGE; 733 return MODE_OK; 734 } 735 736 static enum drm_connector_status 737 radeon_tv_detect(struct drm_connector *connector, bool force) 738 { 739 struct drm_encoder *encoder; 740 struct drm_encoder_helper_funcs *encoder_funcs; 741 struct radeon_connector *radeon_connector = to_radeon_connector(connector); 742 enum drm_connector_status ret = connector_status_disconnected; 743 744 if (!radeon_connector->dac_load_detect) 745 return ret; 746 747 encoder = radeon_best_single_encoder(connector); 748 if (!encoder) 749 ret = connector_status_disconnected; 750 else { 751 encoder_funcs = encoder->helper_private; 752 ret = encoder_funcs->detect(encoder, connector); 753 } 754 if (ret == connector_status_connected) 755 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, false); 756 radeon_connector_update_scratch_regs(connector, ret); 757 return ret; 758 } 759 760 struct drm_connector_helper_funcs radeon_tv_connector_helper_funcs = { 761 .get_modes = radeon_tv_get_modes, 762 .mode_valid = radeon_tv_mode_valid, 763 .best_encoder = radeon_best_single_encoder, 764 }; 765 766 struct drm_connector_funcs radeon_tv_connector_funcs = { 767 .dpms = drm_helper_connector_dpms, 768 .detect = radeon_tv_detect, 769 .fill_modes = drm_helper_probe_single_connector_modes, 770 .destroy = radeon_connector_destroy, 771 .set_property = radeon_connector_set_property, 772 }; 773 774 static int radeon_dvi_get_modes(struct drm_connector *connector) 775 { 776 struct radeon_connector *radeon_connector = to_radeon_connector(connector); 777 int ret; 778 779 ret = radeon_ddc_get_modes(radeon_connector); 780 return ret; 781 } 782 783 /* 784 * DVI is complicated 785 * Do a DDC probe, if DDC probe passes, get the full EDID so 786 * we can do analog/digital monitor detection at this point. 787 * If the monitor is an analog monitor or we got no DDC, 788 * we need to find the DAC encoder object for this connector. 789 * If we got no DDC, we do load detection on the DAC encoder object. 790 * If we got analog DDC or load detection passes on the DAC encoder 791 * we have to check if this analog encoder is shared with anyone else (TV) 792 * if its shared we have to set the other connector to disconnected. 793 */ 794 static enum drm_connector_status 795 radeon_dvi_detect(struct drm_connector *connector, bool force) 796 { 797 struct radeon_connector *radeon_connector = to_radeon_connector(connector); 798 struct drm_encoder *encoder = NULL; 799 struct drm_encoder_helper_funcs *encoder_funcs; 800 struct drm_mode_object *obj; 801 int i; 802 enum drm_connector_status ret = connector_status_disconnected; 803 bool dret = false; 804 805 if (radeon_connector->ddc_bus) 806 dret = radeon_ddc_probe(radeon_connector); 807 if (dret) { 808 if (radeon_connector->edid) { 809 kfree(radeon_connector->edid); 810 radeon_connector->edid = NULL; 811 } 812 radeon_connector->edid = drm_get_edid(&radeon_connector->base, &radeon_connector->ddc_bus->adapter); 813 814 if (!radeon_connector->edid) { 815 DRM_ERROR("%s: probed a monitor but no|invalid EDID\n", 816 drm_get_connector_name(connector)); 817 } else { 818 radeon_connector->use_digital = !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL); 819 820 /* some oems have boards with separate digital and analog connectors 821 * with a shared ddc line (often vga + hdmi) 822 */ 823 if ((!radeon_connector->use_digital) && radeon_connector->shared_ddc) { 824 kfree(radeon_connector->edid); 825 radeon_connector->edid = NULL; 826 ret = connector_status_disconnected; 827 } else 828 ret = connector_status_connected; 829 830 /* This gets complicated. We have boards with VGA + HDMI with a 831 * shared DDC line and we have boards with DVI-D + HDMI with a shared 832 * DDC line. The latter is more complex because with DVI<->HDMI adapters 833 * you don't really know what's connected to which port as both are digital. 834 */ 835 if (radeon_connector->shared_ddc && (ret == connector_status_connected)) { 836 struct drm_device *dev = connector->dev; 837 struct radeon_device *rdev = dev->dev_private; 838 struct drm_connector *list_connector; 839 struct radeon_connector *list_radeon_connector; 840 list_for_each_entry(list_connector, &dev->mode_config.connector_list, head) { 841 if (connector == list_connector) 842 continue; 843 list_radeon_connector = to_radeon_connector(list_connector); 844 if (list_radeon_connector->shared_ddc && 845 (list_radeon_connector->ddc_bus->rec.i2c_id == 846 radeon_connector->ddc_bus->rec.i2c_id)) { 847 /* cases where both connectors are digital */ 848 if (list_connector->connector_type != DRM_MODE_CONNECTOR_VGA) { 849 /* hpd is our only option in this case */ 850 if (!radeon_hpd_sense(rdev, radeon_connector->hpd.hpd)) { 851 kfree(radeon_connector->edid); 852 radeon_connector->edid = NULL; 853 ret = connector_status_disconnected; 854 } 855 } 856 } 857 } 858 } 859 } 860 } 861 862 if ((ret == connector_status_connected) && (radeon_connector->use_digital == true)) 863 goto out; 864 865 if (!force) { 866 ret = connector->status; 867 goto out; 868 } 869 870 /* find analog encoder */ 871 if (radeon_connector->dac_load_detect) { 872 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) { 873 if (connector->encoder_ids[i] == 0) 874 break; 875 876 obj = drm_mode_object_find(connector->dev, 877 connector->encoder_ids[i], 878 DRM_MODE_OBJECT_ENCODER); 879 if (!obj) 880 continue; 881 882 encoder = obj_to_encoder(obj); 883 884 encoder_funcs = encoder->helper_private; 885 if (encoder_funcs->detect) { 886 if (ret != connector_status_connected) { 887 ret = encoder_funcs->detect(encoder, connector); 888 if (ret == connector_status_connected) { 889 radeon_connector->use_digital = false; 890 } 891 } 892 break; 893 } 894 } 895 } 896 897 if ((ret == connector_status_connected) && (radeon_connector->use_digital == false) && 898 encoder) { 899 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true); 900 } 901 902 out: 903 /* updated in get modes as well since we need to know if it's analog or digital */ 904 radeon_connector_update_scratch_regs(connector, ret); 905 return ret; 906 } 907 908 /* okay need to be smart in here about which encoder to pick */ 909 struct drm_encoder *radeon_dvi_encoder(struct drm_connector *connector) 910 { 911 int enc_id = connector->encoder_ids[0]; 912 struct radeon_connector *radeon_connector = to_radeon_connector(connector); 913 struct drm_mode_object *obj; 914 struct drm_encoder *encoder; 915 int i; 916 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) { 917 if (connector->encoder_ids[i] == 0) 918 break; 919 920 obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER); 921 if (!obj) 922 continue; 923 924 encoder = obj_to_encoder(obj); 925 926 if (radeon_connector->use_digital == true) { 927 if (encoder->encoder_type == DRM_MODE_ENCODER_TMDS) 928 return encoder; 929 } else { 930 if (encoder->encoder_type == DRM_MODE_ENCODER_DAC || 931 encoder->encoder_type == DRM_MODE_ENCODER_TVDAC) 932 return encoder; 933 } 934 } 935 936 /* see if we have a default encoder TODO */ 937 938 /* then check use digitial */ 939 /* pick the first one */ 940 if (enc_id) { 941 obj = drm_mode_object_find(connector->dev, enc_id, DRM_MODE_OBJECT_ENCODER); 942 if (!obj) 943 return NULL; 944 encoder = obj_to_encoder(obj); 945 return encoder; 946 } 947 return NULL; 948 } 949 950 static void radeon_dvi_force(struct drm_connector *connector) 951 { 952 struct radeon_connector *radeon_connector = to_radeon_connector(connector); 953 if (connector->force == DRM_FORCE_ON) 954 radeon_connector->use_digital = false; 955 if (connector->force == DRM_FORCE_ON_DIGITAL) 956 radeon_connector->use_digital = true; 957 } 958 959 static int radeon_dvi_mode_valid(struct drm_connector *connector, 960 struct drm_display_mode *mode) 961 { 962 struct drm_device *dev = connector->dev; 963 struct radeon_device *rdev = dev->dev_private; 964 struct radeon_connector *radeon_connector = to_radeon_connector(connector); 965 966 /* XXX check mode bandwidth */ 967 968 /* clocks over 135 MHz have heat issues with DVI on RV100 */ 969 if (radeon_connector->use_digital && 970 (rdev->family == CHIP_RV100) && 971 (mode->clock > 135000)) 972 return MODE_CLOCK_HIGH; 973 974 if (radeon_connector->use_digital && (mode->clock > 165000)) { 975 if ((radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_I) || 976 (radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_D) || 977 (radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_HDMI_TYPE_B)) 978 return MODE_OK; 979 else if (radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_HDMI_TYPE_A) { 980 if (ASIC_IS_DCE3(rdev)) { 981 /* HDMI 1.3+ supports max clock of 340 Mhz */ 982 if (mode->clock > 340000) 983 return MODE_CLOCK_HIGH; 984 else 985 return MODE_OK; 986 } else 987 return MODE_CLOCK_HIGH; 988 } else 989 return MODE_CLOCK_HIGH; 990 } 991 return MODE_OK; 992 } 993 994 struct drm_connector_helper_funcs radeon_dvi_connector_helper_funcs = { 995 .get_modes = radeon_dvi_get_modes, 996 .mode_valid = radeon_dvi_mode_valid, 997 .best_encoder = radeon_dvi_encoder, 998 }; 999 1000 struct drm_connector_funcs radeon_dvi_connector_funcs = { 1001 .dpms = drm_helper_connector_dpms, 1002 .detect = radeon_dvi_detect, 1003 .fill_modes = drm_helper_probe_single_connector_modes, 1004 .set_property = radeon_connector_set_property, 1005 .destroy = radeon_connector_destroy, 1006 .force = radeon_dvi_force, 1007 }; 1008 1009 static void radeon_dp_connector_destroy(struct drm_connector *connector) 1010 { 1011 struct radeon_connector *radeon_connector = to_radeon_connector(connector); 1012 struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv; 1013 1014 if (radeon_connector->edid) 1015 kfree(radeon_connector->edid); 1016 if (radeon_dig_connector->dp_i2c_bus) 1017 radeon_i2c_destroy(radeon_dig_connector->dp_i2c_bus); 1018 kfree(radeon_connector->con_priv); 1019 drm_sysfs_connector_remove(connector); 1020 drm_connector_cleanup(connector); 1021 kfree(connector); 1022 } 1023 1024 static int radeon_dp_get_modes(struct drm_connector *connector) 1025 { 1026 struct radeon_connector *radeon_connector = to_radeon_connector(connector); 1027 struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv; 1028 int ret; 1029 1030 if (connector->connector_type == DRM_MODE_CONNECTOR_eDP) { 1031 if (!radeon_dig_connector->edp_on) 1032 atombios_set_edp_panel_power(connector, 1033 ATOM_TRANSMITTER_ACTION_POWER_ON); 1034 } 1035 ret = radeon_ddc_get_modes(radeon_connector); 1036 if (connector->connector_type == DRM_MODE_CONNECTOR_eDP) { 1037 if (!radeon_dig_connector->edp_on) 1038 atombios_set_edp_panel_power(connector, 1039 ATOM_TRANSMITTER_ACTION_POWER_OFF); 1040 } 1041 1042 return ret; 1043 } 1044 1045 static enum drm_connector_status 1046 radeon_dp_detect(struct drm_connector *connector, bool force) 1047 { 1048 struct radeon_connector *radeon_connector = to_radeon_connector(connector); 1049 enum drm_connector_status ret = connector_status_disconnected; 1050 struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv; 1051 1052 if (radeon_connector->edid) { 1053 kfree(radeon_connector->edid); 1054 radeon_connector->edid = NULL; 1055 } 1056 1057 if (connector->connector_type == DRM_MODE_CONNECTOR_eDP) { 1058 /* eDP is always DP */ 1059 radeon_dig_connector->dp_sink_type = CONNECTOR_OBJECT_ID_DISPLAYPORT; 1060 if (!radeon_dig_connector->edp_on) 1061 atombios_set_edp_panel_power(connector, 1062 ATOM_TRANSMITTER_ACTION_POWER_ON); 1063 if (radeon_dp_getdpcd(radeon_connector)) 1064 ret = connector_status_connected; 1065 if (!radeon_dig_connector->edp_on) 1066 atombios_set_edp_panel_power(connector, 1067 ATOM_TRANSMITTER_ACTION_POWER_OFF); 1068 } else { 1069 radeon_dig_connector->dp_sink_type = radeon_dp_getsinktype(radeon_connector); 1070 if (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) { 1071 if (radeon_dp_getdpcd(radeon_connector)) 1072 ret = connector_status_connected; 1073 } else { 1074 if (radeon_ddc_probe(radeon_connector)) 1075 ret = connector_status_connected; 1076 } 1077 } 1078 1079 radeon_connector_update_scratch_regs(connector, ret); 1080 return ret; 1081 } 1082 1083 static int radeon_dp_mode_valid(struct drm_connector *connector, 1084 struct drm_display_mode *mode) 1085 { 1086 struct radeon_connector *radeon_connector = to_radeon_connector(connector); 1087 struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv; 1088 1089 /* XXX check mode bandwidth */ 1090 1091 if ((radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) || 1092 (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_eDP)) 1093 return radeon_dp_mode_valid_helper(radeon_connector, mode); 1094 else 1095 return MODE_OK; 1096 } 1097 1098 struct drm_connector_helper_funcs radeon_dp_connector_helper_funcs = { 1099 .get_modes = radeon_dp_get_modes, 1100 .mode_valid = radeon_dp_mode_valid, 1101 .best_encoder = radeon_dvi_encoder, 1102 }; 1103 1104 struct drm_connector_funcs radeon_dp_connector_funcs = { 1105 .dpms = drm_helper_connector_dpms, 1106 .detect = radeon_dp_detect, 1107 .fill_modes = drm_helper_probe_single_connector_modes, 1108 .set_property = radeon_connector_set_property, 1109 .destroy = radeon_dp_connector_destroy, 1110 .force = radeon_dvi_force, 1111 }; 1112 1113 void 1114 radeon_add_atom_connector(struct drm_device *dev, 1115 uint32_t connector_id, 1116 uint32_t supported_device, 1117 int connector_type, 1118 struct radeon_i2c_bus_rec *i2c_bus, 1119 uint32_t igp_lane_info, 1120 uint16_t connector_object_id, 1121 struct radeon_hpd *hpd, 1122 struct radeon_router *router) 1123 { 1124 struct radeon_device *rdev = dev->dev_private; 1125 struct drm_connector *connector; 1126 struct radeon_connector *radeon_connector; 1127 struct radeon_connector_atom_dig *radeon_dig_connector; 1128 uint32_t subpixel_order = SubPixelNone; 1129 bool shared_ddc = false; 1130 1131 if (connector_type == DRM_MODE_CONNECTOR_Unknown) 1132 return; 1133 1134 /* if the user selected tv=0 don't try and add the connector */ 1135 if (((connector_type == DRM_MODE_CONNECTOR_SVIDEO) || 1136 (connector_type == DRM_MODE_CONNECTOR_Composite) || 1137 (connector_type == DRM_MODE_CONNECTOR_9PinDIN)) && 1138 (radeon_tv == 0)) 1139 return; 1140 1141 /* see if we already added it */ 1142 list_for_each_entry(connector, &dev->mode_config.connector_list, head) { 1143 radeon_connector = to_radeon_connector(connector); 1144 if (radeon_connector->connector_id == connector_id) { 1145 radeon_connector->devices |= supported_device; 1146 return; 1147 } 1148 if (radeon_connector->ddc_bus && i2c_bus->valid) { 1149 if (radeon_connector->ddc_bus->rec.i2c_id == i2c_bus->i2c_id) { 1150 radeon_connector->shared_ddc = true; 1151 shared_ddc = true; 1152 } 1153 if (radeon_connector->router_bus && router->ddc_valid && 1154 (radeon_connector->router.router_id == router->router_id)) { 1155 radeon_connector->shared_ddc = false; 1156 shared_ddc = false; 1157 } 1158 } 1159 } 1160 1161 radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL); 1162 if (!radeon_connector) 1163 return; 1164 1165 connector = &radeon_connector->base; 1166 1167 radeon_connector->connector_id = connector_id; 1168 radeon_connector->devices = supported_device; 1169 radeon_connector->shared_ddc = shared_ddc; 1170 radeon_connector->connector_object_id = connector_object_id; 1171 radeon_connector->hpd = *hpd; 1172 radeon_connector->router = *router; 1173 if (router->ddc_valid || router->cd_valid) { 1174 radeon_connector->router_bus = radeon_i2c_lookup(rdev, &router->i2c_info); 1175 if (!radeon_connector->router_bus) 1176 goto failed; 1177 } 1178 switch (connector_type) { 1179 case DRM_MODE_CONNECTOR_VGA: 1180 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type); 1181 drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs); 1182 if (i2c_bus->valid) { 1183 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus); 1184 if (!radeon_connector->ddc_bus) 1185 goto failed; 1186 } 1187 radeon_connector->dac_load_detect = true; 1188 drm_connector_attach_property(&radeon_connector->base, 1189 rdev->mode_info.load_detect_property, 1190 1); 1191 /* no HPD on analog connectors */ 1192 radeon_connector->hpd.hpd = RADEON_HPD_NONE; 1193 connector->polled = DRM_CONNECTOR_POLL_CONNECT; 1194 connector->interlace_allowed = true; 1195 connector->doublescan_allowed = true; 1196 break; 1197 case DRM_MODE_CONNECTOR_DVIA: 1198 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type); 1199 drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs); 1200 if (i2c_bus->valid) { 1201 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus); 1202 if (!radeon_connector->ddc_bus) 1203 goto failed; 1204 } 1205 radeon_connector->dac_load_detect = true; 1206 drm_connector_attach_property(&radeon_connector->base, 1207 rdev->mode_info.load_detect_property, 1208 1); 1209 /* no HPD on analog connectors */ 1210 radeon_connector->hpd.hpd = RADEON_HPD_NONE; 1211 connector->interlace_allowed = true; 1212 connector->doublescan_allowed = true; 1213 break; 1214 case DRM_MODE_CONNECTOR_DVII: 1215 case DRM_MODE_CONNECTOR_DVID: 1216 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL); 1217 if (!radeon_dig_connector) 1218 goto failed; 1219 radeon_dig_connector->igp_lane_info = igp_lane_info; 1220 radeon_connector->con_priv = radeon_dig_connector; 1221 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type); 1222 drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs); 1223 if (i2c_bus->valid) { 1224 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus); 1225 if (!radeon_connector->ddc_bus) 1226 goto failed; 1227 } 1228 subpixel_order = SubPixelHorizontalRGB; 1229 drm_connector_attach_property(&radeon_connector->base, 1230 rdev->mode_info.coherent_mode_property, 1231 1); 1232 if (ASIC_IS_AVIVO(rdev)) { 1233 drm_connector_attach_property(&radeon_connector->base, 1234 rdev->mode_info.underscan_property, 1235 UNDERSCAN_OFF); 1236 drm_connector_attach_property(&radeon_connector->base, 1237 rdev->mode_info.underscan_hborder_property, 1238 0); 1239 drm_connector_attach_property(&radeon_connector->base, 1240 rdev->mode_info.underscan_vborder_property, 1241 0); 1242 } 1243 if (connector_type == DRM_MODE_CONNECTOR_DVII) { 1244 radeon_connector->dac_load_detect = true; 1245 drm_connector_attach_property(&radeon_connector->base, 1246 rdev->mode_info.load_detect_property, 1247 1); 1248 } 1249 connector->interlace_allowed = true; 1250 if (connector_type == DRM_MODE_CONNECTOR_DVII) 1251 connector->doublescan_allowed = true; 1252 else 1253 connector->doublescan_allowed = false; 1254 break; 1255 case DRM_MODE_CONNECTOR_HDMIA: 1256 case DRM_MODE_CONNECTOR_HDMIB: 1257 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL); 1258 if (!radeon_dig_connector) 1259 goto failed; 1260 radeon_dig_connector->igp_lane_info = igp_lane_info; 1261 radeon_connector->con_priv = radeon_dig_connector; 1262 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type); 1263 drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs); 1264 if (i2c_bus->valid) { 1265 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus); 1266 if (!radeon_connector->ddc_bus) 1267 goto failed; 1268 } 1269 drm_connector_attach_property(&radeon_connector->base, 1270 rdev->mode_info.coherent_mode_property, 1271 1); 1272 if (ASIC_IS_AVIVO(rdev)) { 1273 drm_connector_attach_property(&radeon_connector->base, 1274 rdev->mode_info.underscan_property, 1275 UNDERSCAN_OFF); 1276 drm_connector_attach_property(&radeon_connector->base, 1277 rdev->mode_info.underscan_hborder_property, 1278 0); 1279 drm_connector_attach_property(&radeon_connector->base, 1280 rdev->mode_info.underscan_vborder_property, 1281 0); 1282 } 1283 subpixel_order = SubPixelHorizontalRGB; 1284 connector->interlace_allowed = true; 1285 if (connector_type == DRM_MODE_CONNECTOR_HDMIB) 1286 connector->doublescan_allowed = true; 1287 else 1288 connector->doublescan_allowed = false; 1289 break; 1290 case DRM_MODE_CONNECTOR_DisplayPort: 1291 case DRM_MODE_CONNECTOR_eDP: 1292 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL); 1293 if (!radeon_dig_connector) 1294 goto failed; 1295 radeon_dig_connector->igp_lane_info = igp_lane_info; 1296 radeon_connector->con_priv = radeon_dig_connector; 1297 drm_connector_init(dev, &radeon_connector->base, &radeon_dp_connector_funcs, connector_type); 1298 drm_connector_helper_add(&radeon_connector->base, &radeon_dp_connector_helper_funcs); 1299 if (i2c_bus->valid) { 1300 /* add DP i2c bus */ 1301 if (connector_type == DRM_MODE_CONNECTOR_eDP) 1302 radeon_dig_connector->dp_i2c_bus = radeon_i2c_create_dp(dev, i2c_bus, "eDP-auxch"); 1303 else 1304 radeon_dig_connector->dp_i2c_bus = radeon_i2c_create_dp(dev, i2c_bus, "DP-auxch"); 1305 if (!radeon_dig_connector->dp_i2c_bus) 1306 goto failed; 1307 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus); 1308 if (!radeon_connector->ddc_bus) 1309 goto failed; 1310 } 1311 subpixel_order = SubPixelHorizontalRGB; 1312 drm_connector_attach_property(&radeon_connector->base, 1313 rdev->mode_info.coherent_mode_property, 1314 1); 1315 if (ASIC_IS_AVIVO(rdev)) { 1316 drm_connector_attach_property(&radeon_connector->base, 1317 rdev->mode_info.underscan_property, 1318 UNDERSCAN_OFF); 1319 drm_connector_attach_property(&radeon_connector->base, 1320 rdev->mode_info.underscan_hborder_property, 1321 0); 1322 drm_connector_attach_property(&radeon_connector->base, 1323 rdev->mode_info.underscan_vborder_property, 1324 0); 1325 } 1326 connector->interlace_allowed = true; 1327 /* in theory with a DP to VGA converter... */ 1328 connector->doublescan_allowed = false; 1329 break; 1330 case DRM_MODE_CONNECTOR_SVIDEO: 1331 case DRM_MODE_CONNECTOR_Composite: 1332 case DRM_MODE_CONNECTOR_9PinDIN: 1333 drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type); 1334 drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs); 1335 radeon_connector->dac_load_detect = true; 1336 drm_connector_attach_property(&radeon_connector->base, 1337 rdev->mode_info.load_detect_property, 1338 1); 1339 drm_connector_attach_property(&radeon_connector->base, 1340 rdev->mode_info.tv_std_property, 1341 radeon_atombios_get_tv_info(rdev)); 1342 /* no HPD on analog connectors */ 1343 radeon_connector->hpd.hpd = RADEON_HPD_NONE; 1344 connector->interlace_allowed = false; 1345 connector->doublescan_allowed = false; 1346 break; 1347 case DRM_MODE_CONNECTOR_LVDS: 1348 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL); 1349 if (!radeon_dig_connector) 1350 goto failed; 1351 radeon_dig_connector->igp_lane_info = igp_lane_info; 1352 radeon_connector->con_priv = radeon_dig_connector; 1353 drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type); 1354 drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs); 1355 if (i2c_bus->valid) { 1356 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus); 1357 if (!radeon_connector->ddc_bus) 1358 goto failed; 1359 } 1360 drm_connector_attach_property(&radeon_connector->base, 1361 dev->mode_config.scaling_mode_property, 1362 DRM_MODE_SCALE_FULLSCREEN); 1363 subpixel_order = SubPixelHorizontalRGB; 1364 connector->interlace_allowed = false; 1365 connector->doublescan_allowed = false; 1366 break; 1367 } 1368 1369 if (radeon_connector->hpd.hpd == RADEON_HPD_NONE) { 1370 if (i2c_bus->valid) 1371 connector->polled = DRM_CONNECTOR_POLL_CONNECT; 1372 } else 1373 connector->polled = DRM_CONNECTOR_POLL_HPD; 1374 1375 connector->display_info.subpixel_order = subpixel_order; 1376 drm_sysfs_connector_add(connector); 1377 return; 1378 1379 failed: 1380 drm_connector_cleanup(connector); 1381 kfree(connector); 1382 } 1383 1384 void 1385 radeon_add_legacy_connector(struct drm_device *dev, 1386 uint32_t connector_id, 1387 uint32_t supported_device, 1388 int connector_type, 1389 struct radeon_i2c_bus_rec *i2c_bus, 1390 uint16_t connector_object_id, 1391 struct radeon_hpd *hpd) 1392 { 1393 struct radeon_device *rdev = dev->dev_private; 1394 struct drm_connector *connector; 1395 struct radeon_connector *radeon_connector; 1396 uint32_t subpixel_order = SubPixelNone; 1397 1398 if (connector_type == DRM_MODE_CONNECTOR_Unknown) 1399 return; 1400 1401 /* if the user selected tv=0 don't try and add the connector */ 1402 if (((connector_type == DRM_MODE_CONNECTOR_SVIDEO) || 1403 (connector_type == DRM_MODE_CONNECTOR_Composite) || 1404 (connector_type == DRM_MODE_CONNECTOR_9PinDIN)) && 1405 (radeon_tv == 0)) 1406 return; 1407 1408 /* see if we already added it */ 1409 list_for_each_entry(connector, &dev->mode_config.connector_list, head) { 1410 radeon_connector = to_radeon_connector(connector); 1411 if (radeon_connector->connector_id == connector_id) { 1412 radeon_connector->devices |= supported_device; 1413 return; 1414 } 1415 } 1416 1417 radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL); 1418 if (!radeon_connector) 1419 return; 1420 1421 connector = &radeon_connector->base; 1422 1423 radeon_connector->connector_id = connector_id; 1424 radeon_connector->devices = supported_device; 1425 radeon_connector->connector_object_id = connector_object_id; 1426 radeon_connector->hpd = *hpd; 1427 switch (connector_type) { 1428 case DRM_MODE_CONNECTOR_VGA: 1429 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type); 1430 drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs); 1431 if (i2c_bus->valid) { 1432 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus); 1433 if (!radeon_connector->ddc_bus) 1434 goto failed; 1435 } 1436 radeon_connector->dac_load_detect = true; 1437 drm_connector_attach_property(&radeon_connector->base, 1438 rdev->mode_info.load_detect_property, 1439 1); 1440 /* no HPD on analog connectors */ 1441 radeon_connector->hpd.hpd = RADEON_HPD_NONE; 1442 connector->polled = DRM_CONNECTOR_POLL_CONNECT; 1443 connector->interlace_allowed = true; 1444 connector->doublescan_allowed = true; 1445 break; 1446 case DRM_MODE_CONNECTOR_DVIA: 1447 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type); 1448 drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs); 1449 if (i2c_bus->valid) { 1450 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus); 1451 if (!radeon_connector->ddc_bus) 1452 goto failed; 1453 } 1454 radeon_connector->dac_load_detect = true; 1455 drm_connector_attach_property(&radeon_connector->base, 1456 rdev->mode_info.load_detect_property, 1457 1); 1458 /* no HPD on analog connectors */ 1459 radeon_connector->hpd.hpd = RADEON_HPD_NONE; 1460 connector->interlace_allowed = true; 1461 connector->doublescan_allowed = true; 1462 break; 1463 case DRM_MODE_CONNECTOR_DVII: 1464 case DRM_MODE_CONNECTOR_DVID: 1465 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type); 1466 drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs); 1467 if (i2c_bus->valid) { 1468 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus); 1469 if (!radeon_connector->ddc_bus) 1470 goto failed; 1471 } 1472 if (connector_type == DRM_MODE_CONNECTOR_DVII) { 1473 radeon_connector->dac_load_detect = true; 1474 drm_connector_attach_property(&radeon_connector->base, 1475 rdev->mode_info.load_detect_property, 1476 1); 1477 } 1478 subpixel_order = SubPixelHorizontalRGB; 1479 connector->interlace_allowed = true; 1480 if (connector_type == DRM_MODE_CONNECTOR_DVII) 1481 connector->doublescan_allowed = true; 1482 else 1483 connector->doublescan_allowed = false; 1484 break; 1485 case DRM_MODE_CONNECTOR_SVIDEO: 1486 case DRM_MODE_CONNECTOR_Composite: 1487 case DRM_MODE_CONNECTOR_9PinDIN: 1488 drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type); 1489 drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs); 1490 radeon_connector->dac_load_detect = true; 1491 /* RS400,RC410,RS480 chipset seems to report a lot 1492 * of false positive on load detect, we haven't yet 1493 * found a way to make load detect reliable on those 1494 * chipset, thus just disable it for TV. 1495 */ 1496 if (rdev->family == CHIP_RS400 || rdev->family == CHIP_RS480) 1497 radeon_connector->dac_load_detect = false; 1498 drm_connector_attach_property(&radeon_connector->base, 1499 rdev->mode_info.load_detect_property, 1500 radeon_connector->dac_load_detect); 1501 drm_connector_attach_property(&radeon_connector->base, 1502 rdev->mode_info.tv_std_property, 1503 radeon_combios_get_tv_info(rdev)); 1504 /* no HPD on analog connectors */ 1505 radeon_connector->hpd.hpd = RADEON_HPD_NONE; 1506 connector->interlace_allowed = false; 1507 connector->doublescan_allowed = false; 1508 break; 1509 case DRM_MODE_CONNECTOR_LVDS: 1510 drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type); 1511 drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs); 1512 if (i2c_bus->valid) { 1513 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus); 1514 if (!radeon_connector->ddc_bus) 1515 goto failed; 1516 } 1517 drm_connector_attach_property(&radeon_connector->base, 1518 dev->mode_config.scaling_mode_property, 1519 DRM_MODE_SCALE_FULLSCREEN); 1520 subpixel_order = SubPixelHorizontalRGB; 1521 connector->interlace_allowed = false; 1522 connector->doublescan_allowed = false; 1523 break; 1524 } 1525 1526 if (radeon_connector->hpd.hpd == RADEON_HPD_NONE) { 1527 if (i2c_bus->valid) 1528 connector->polled = DRM_CONNECTOR_POLL_CONNECT; 1529 } else 1530 connector->polled = DRM_CONNECTOR_POLL_HPD; 1531 connector->display_info.subpixel_order = subpixel_order; 1532 drm_sysfs_connector_add(connector); 1533 if (connector_type == DRM_MODE_CONNECTOR_LVDS) { 1534 struct drm_encoder *drm_encoder; 1535 1536 list_for_each_entry(drm_encoder, &dev->mode_config.encoder_list, head) { 1537 struct radeon_encoder *radeon_encoder; 1538 1539 radeon_encoder = to_radeon_encoder(drm_encoder); 1540 if (radeon_encoder->encoder_id == ENCODER_OBJECT_ID_INTERNAL_LVDS) 1541 radeon_legacy_backlight_init(radeon_encoder, connector); 1542 } 1543 } 1544 return; 1545 1546 failed: 1547 drm_connector_cleanup(connector); 1548 kfree(connector); 1549 } 1550