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