1 /* 2 * Copyright (C) 2008 Maarten Maathuis. 3 * All Rights Reserved. 4 * 5 * Permission is hereby granted, free of charge, to any person obtaining 6 * a copy of this software and associated documentation files (the 7 * "Software"), to deal in the Software without restriction, including 8 * without limitation the rights to use, copy, modify, merge, publish, 9 * distribute, sublicense, and/or sell copies of the Software, and to 10 * permit persons to whom the Software is furnished to do so, subject to 11 * the following conditions: 12 * 13 * The above copyright notice and this permission notice (including the 14 * next paragraph) shall be included in all copies or substantial 15 * portions of the Software. 16 * 17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 18 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 19 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 20 * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE 21 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION 22 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 23 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 24 * 25 */ 26 27 #include <acpi/button.h> 28 29 #include "drmP.h" 30 #include "drm_edid.h" 31 #include "drm_crtc_helper.h" 32 33 #include "nouveau_reg.h" 34 #include "nouveau_drv.h" 35 #include "nouveau_encoder.h" 36 #include "nouveau_crtc.h" 37 #include "nouveau_connector.h" 38 #include "nouveau_hw.h" 39 40 static void nouveau_connector_hotplug(void *, int); 41 42 static struct nouveau_encoder * 43 find_encoder(struct drm_connector *connector, int type) 44 { 45 struct drm_device *dev = connector->dev; 46 struct nouveau_encoder *nv_encoder; 47 struct drm_mode_object *obj; 48 int i, id; 49 50 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) { 51 id = connector->encoder_ids[i]; 52 if (!id) 53 break; 54 55 obj = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_ENCODER); 56 if (!obj) 57 continue; 58 nv_encoder = nouveau_encoder(obj_to_encoder(obj)); 59 60 if (type == OUTPUT_ANY || nv_encoder->dcb->type == type) 61 return nv_encoder; 62 } 63 64 return NULL; 65 } 66 67 struct nouveau_connector * 68 nouveau_encoder_connector_get(struct nouveau_encoder *encoder) 69 { 70 struct drm_device *dev = to_drm_encoder(encoder)->dev; 71 struct drm_connector *drm_connector; 72 73 list_for_each_entry(drm_connector, &dev->mode_config.connector_list, head) { 74 if (drm_connector->encoder == to_drm_encoder(encoder)) 75 return nouveau_connector(drm_connector); 76 } 77 78 return NULL; 79 } 80 81 /*TODO: This could use improvement, and learn to handle the fixed 82 * BIOS tables etc. It's fine currently, for its only user. 83 */ 84 int 85 nouveau_connector_bpp(struct drm_connector *connector) 86 { 87 struct nouveau_connector *nv_connector = nouveau_connector(connector); 88 89 if (nv_connector->edid && nv_connector->edid->revision >= 4) { 90 u8 bpc = ((nv_connector->edid->input & 0x70) >> 3) + 4; 91 if (bpc > 4) 92 return bpc; 93 } 94 95 return 18; 96 } 97 98 static void 99 nouveau_connector_destroy(struct drm_connector *connector) 100 { 101 struct nouveau_connector *nv_connector = nouveau_connector(connector); 102 struct drm_nouveau_private *dev_priv; 103 struct nouveau_gpio_engine *pgpio; 104 struct drm_device *dev; 105 106 if (!nv_connector) 107 return; 108 109 dev = nv_connector->base.dev; 110 dev_priv = dev->dev_private; 111 NV_DEBUG_KMS(dev, "\n"); 112 113 pgpio = &dev_priv->engine.gpio; 114 if (pgpio->irq_unregister) { 115 pgpio->irq_unregister(dev, nv_connector->dcb->gpio_tag, 116 nouveau_connector_hotplug, connector); 117 } 118 119 if (connector->connector_type == DRM_MODE_CONNECTOR_LVDS || 120 connector->connector_type == DRM_MODE_CONNECTOR_eDP) 121 nouveau_backlight_exit(connector); 122 123 kfree(nv_connector->edid); 124 drm_sysfs_connector_remove(connector); 125 drm_connector_cleanup(connector); 126 kfree(connector); 127 } 128 129 static struct nouveau_i2c_chan * 130 nouveau_connector_ddc_detect(struct drm_connector *connector, 131 struct nouveau_encoder **pnv_encoder) 132 { 133 struct drm_device *dev = connector->dev; 134 int i; 135 136 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) { 137 struct nouveau_i2c_chan *i2c = NULL; 138 struct nouveau_encoder *nv_encoder; 139 struct drm_mode_object *obj; 140 int id; 141 142 id = connector->encoder_ids[i]; 143 if (!id) 144 break; 145 146 obj = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_ENCODER); 147 if (!obj) 148 continue; 149 nv_encoder = nouveau_encoder(obj_to_encoder(obj)); 150 151 if (nv_encoder->dcb->i2c_index < 0xf) 152 i2c = nouveau_i2c_find(dev, nv_encoder->dcb->i2c_index); 153 154 if (i2c && nouveau_probe_i2c_addr(i2c, 0x50)) { 155 *pnv_encoder = nv_encoder; 156 return i2c; 157 } 158 } 159 160 return NULL; 161 } 162 163 static struct nouveau_encoder * 164 nouveau_connector_of_detect(struct drm_connector *connector) 165 { 166 #ifdef __powerpc__ 167 struct drm_device *dev = connector->dev; 168 struct nouveau_connector *nv_connector = nouveau_connector(connector); 169 struct nouveau_encoder *nv_encoder; 170 struct device_node *cn, *dn = pci_device_to_OF_node(dev->pdev); 171 172 if (!dn || 173 !((nv_encoder = find_encoder(connector, OUTPUT_TMDS)) || 174 (nv_encoder = find_encoder(connector, OUTPUT_ANALOG)))) 175 return NULL; 176 177 for_each_child_of_node(dn, cn) { 178 const char *name = of_get_property(cn, "name", NULL); 179 const void *edid = of_get_property(cn, "EDID", NULL); 180 int idx = name ? name[strlen(name) - 1] - 'A' : 0; 181 182 if (nv_encoder->dcb->i2c_index == idx && edid) { 183 nv_connector->edid = 184 kmemdup(edid, EDID_LENGTH, GFP_KERNEL); 185 of_node_put(cn); 186 return nv_encoder; 187 } 188 } 189 #endif 190 return NULL; 191 } 192 193 static void 194 nouveau_connector_set_encoder(struct drm_connector *connector, 195 struct nouveau_encoder *nv_encoder) 196 { 197 struct nouveau_connector *nv_connector = nouveau_connector(connector); 198 struct drm_nouveau_private *dev_priv = connector->dev->dev_private; 199 struct drm_device *dev = connector->dev; 200 201 if (nv_connector->detected_encoder == nv_encoder) 202 return; 203 nv_connector->detected_encoder = nv_encoder; 204 205 if (nv_encoder->dcb->type == OUTPUT_LVDS || 206 nv_encoder->dcb->type == OUTPUT_TMDS) { 207 connector->doublescan_allowed = false; 208 connector->interlace_allowed = false; 209 } else { 210 connector->doublescan_allowed = true; 211 if (dev_priv->card_type == NV_20 || 212 (dev_priv->card_type == NV_10 && 213 (dev->pci_device & 0x0ff0) != 0x0100 && 214 (dev->pci_device & 0x0ff0) != 0x0150)) 215 /* HW is broken */ 216 connector->interlace_allowed = false; 217 else 218 connector->interlace_allowed = true; 219 } 220 221 if (nv_connector->dcb->type == DCB_CONNECTOR_DVI_I) { 222 drm_connector_property_set_value(connector, 223 dev->mode_config.dvi_i_subconnector_property, 224 nv_encoder->dcb->type == OUTPUT_TMDS ? 225 DRM_MODE_SUBCONNECTOR_DVID : 226 DRM_MODE_SUBCONNECTOR_DVIA); 227 } 228 } 229 230 static enum drm_connector_status 231 nouveau_connector_detect(struct drm_connector *connector, bool force) 232 { 233 struct drm_device *dev = connector->dev; 234 struct nouveau_connector *nv_connector = nouveau_connector(connector); 235 struct nouveau_encoder *nv_encoder = NULL; 236 struct nouveau_encoder *nv_partner; 237 struct nouveau_i2c_chan *i2c; 238 int type; 239 240 /* Cleanup the previous EDID block. */ 241 if (nv_connector->edid) { 242 drm_mode_connector_update_edid_property(connector, NULL); 243 kfree(nv_connector->edid); 244 nv_connector->edid = NULL; 245 } 246 247 i2c = nouveau_connector_ddc_detect(connector, &nv_encoder); 248 if (i2c) { 249 nv_connector->edid = drm_get_edid(connector, &i2c->adapter); 250 drm_mode_connector_update_edid_property(connector, 251 nv_connector->edid); 252 if (!nv_connector->edid) { 253 NV_ERROR(dev, "DDC responded, but no EDID for %s\n", 254 drm_get_connector_name(connector)); 255 goto detect_analog; 256 } 257 258 if (nv_encoder->dcb->type == OUTPUT_DP && 259 !nouveau_dp_detect(to_drm_encoder(nv_encoder))) { 260 NV_ERROR(dev, "Detected %s, but failed init\n", 261 drm_get_connector_name(connector)); 262 return connector_status_disconnected; 263 } 264 265 /* Override encoder type for DVI-I based on whether EDID 266 * says the display is digital or analog, both use the 267 * same i2c channel so the value returned from ddc_detect 268 * isn't necessarily correct. 269 */ 270 nv_partner = NULL; 271 if (nv_encoder->dcb->type == OUTPUT_TMDS) 272 nv_partner = find_encoder(connector, OUTPUT_ANALOG); 273 if (nv_encoder->dcb->type == OUTPUT_ANALOG) 274 nv_partner = find_encoder(connector, OUTPUT_TMDS); 275 276 if (nv_partner && ((nv_encoder->dcb->type == OUTPUT_ANALOG && 277 nv_partner->dcb->type == OUTPUT_TMDS) || 278 (nv_encoder->dcb->type == OUTPUT_TMDS && 279 nv_partner->dcb->type == OUTPUT_ANALOG))) { 280 if (nv_connector->edid->input & DRM_EDID_INPUT_DIGITAL) 281 type = OUTPUT_TMDS; 282 else 283 type = OUTPUT_ANALOG; 284 285 nv_encoder = find_encoder(connector, type); 286 } 287 288 nouveau_connector_set_encoder(connector, nv_encoder); 289 return connector_status_connected; 290 } 291 292 nv_encoder = nouveau_connector_of_detect(connector); 293 if (nv_encoder) { 294 nouveau_connector_set_encoder(connector, nv_encoder); 295 return connector_status_connected; 296 } 297 298 detect_analog: 299 nv_encoder = find_encoder(connector, OUTPUT_ANALOG); 300 if (!nv_encoder && !nouveau_tv_disable) 301 nv_encoder = find_encoder(connector, OUTPUT_TV); 302 if (nv_encoder && force) { 303 struct drm_encoder *encoder = to_drm_encoder(nv_encoder); 304 struct drm_encoder_helper_funcs *helper = 305 encoder->helper_private; 306 307 if (helper->detect(encoder, connector) == 308 connector_status_connected) { 309 nouveau_connector_set_encoder(connector, nv_encoder); 310 return connector_status_connected; 311 } 312 313 } 314 315 return connector_status_disconnected; 316 } 317 318 static enum drm_connector_status 319 nouveau_connector_detect_lvds(struct drm_connector *connector, bool force) 320 { 321 struct drm_device *dev = connector->dev; 322 struct drm_nouveau_private *dev_priv = dev->dev_private; 323 struct nouveau_connector *nv_connector = nouveau_connector(connector); 324 struct nouveau_encoder *nv_encoder = NULL; 325 enum drm_connector_status status = connector_status_disconnected; 326 327 /* Cleanup the previous EDID block. */ 328 if (nv_connector->edid) { 329 drm_mode_connector_update_edid_property(connector, NULL); 330 kfree(nv_connector->edid); 331 nv_connector->edid = NULL; 332 } 333 334 nv_encoder = find_encoder(connector, OUTPUT_LVDS); 335 if (!nv_encoder) 336 return connector_status_disconnected; 337 338 /* Try retrieving EDID via DDC */ 339 if (!dev_priv->vbios.fp_no_ddc) { 340 status = nouveau_connector_detect(connector, force); 341 if (status == connector_status_connected) 342 goto out; 343 } 344 345 /* On some laptops (Sony, i'm looking at you) there appears to 346 * be no direct way of accessing the panel's EDID. The only 347 * option available to us appears to be to ask ACPI for help.. 348 * 349 * It's important this check's before trying straps, one of the 350 * said manufacturer's laptops are configured in such a way 351 * the nouveau decides an entry in the VBIOS FP mode table is 352 * valid - it's not (rh#613284) 353 */ 354 if (nv_encoder->dcb->lvdsconf.use_acpi_for_edid) { 355 if (!nouveau_acpi_edid(dev, connector)) { 356 status = connector_status_connected; 357 goto out; 358 } 359 } 360 361 /* If no EDID found above, and the VBIOS indicates a hardcoded 362 * modeline is avalilable for the panel, set it as the panel's 363 * native mode and exit. 364 */ 365 if (nouveau_bios_fp_mode(dev, NULL) && (dev_priv->vbios.fp_no_ddc || 366 nv_encoder->dcb->lvdsconf.use_straps_for_mode)) { 367 status = connector_status_connected; 368 goto out; 369 } 370 371 /* Still nothing, some VBIOS images have a hardcoded EDID block 372 * stored for the panel stored in them. 373 */ 374 if (!dev_priv->vbios.fp_no_ddc) { 375 struct edid *edid = 376 (struct edid *)nouveau_bios_embedded_edid(dev); 377 if (edid) { 378 nv_connector->edid = kmalloc(EDID_LENGTH, GFP_KERNEL); 379 *(nv_connector->edid) = *edid; 380 status = connector_status_connected; 381 } 382 } 383 384 out: 385 #if defined(CONFIG_ACPI_BUTTON) || \ 386 (defined(CONFIG_ACPI_BUTTON_MODULE) && defined(MODULE)) 387 if (status == connector_status_connected && 388 !nouveau_ignorelid && !acpi_lid_open()) 389 status = connector_status_unknown; 390 #endif 391 392 drm_mode_connector_update_edid_property(connector, nv_connector->edid); 393 nouveau_connector_set_encoder(connector, nv_encoder); 394 return status; 395 } 396 397 static void 398 nouveau_connector_force(struct drm_connector *connector) 399 { 400 struct nouveau_connector *nv_connector = nouveau_connector(connector); 401 struct nouveau_encoder *nv_encoder; 402 int type; 403 404 if (nv_connector->dcb->type == DCB_CONNECTOR_DVI_I) { 405 if (connector->force == DRM_FORCE_ON_DIGITAL) 406 type = OUTPUT_TMDS; 407 else 408 type = OUTPUT_ANALOG; 409 } else 410 type = OUTPUT_ANY; 411 412 nv_encoder = find_encoder(connector, type); 413 if (!nv_encoder) { 414 NV_ERROR(connector->dev, "can't find encoder to force %s on!\n", 415 drm_get_connector_name(connector)); 416 connector->status = connector_status_disconnected; 417 return; 418 } 419 420 nouveau_connector_set_encoder(connector, nv_encoder); 421 } 422 423 static int 424 nouveau_connector_set_property(struct drm_connector *connector, 425 struct drm_property *property, uint64_t value) 426 { 427 struct nouveau_connector *nv_connector = nouveau_connector(connector); 428 struct nouveau_encoder *nv_encoder = nv_connector->detected_encoder; 429 struct drm_encoder *encoder = to_drm_encoder(nv_encoder); 430 struct drm_device *dev = connector->dev; 431 int ret; 432 433 /* Scaling mode */ 434 if (property == dev->mode_config.scaling_mode_property) { 435 struct nouveau_crtc *nv_crtc = NULL; 436 bool modeset = false; 437 438 switch (value) { 439 case DRM_MODE_SCALE_NONE: 440 case DRM_MODE_SCALE_FULLSCREEN: 441 case DRM_MODE_SCALE_CENTER: 442 case DRM_MODE_SCALE_ASPECT: 443 break; 444 default: 445 return -EINVAL; 446 } 447 448 /* LVDS always needs gpu scaling */ 449 if (connector->connector_type == DRM_MODE_CONNECTOR_LVDS && 450 value == DRM_MODE_SCALE_NONE) 451 return -EINVAL; 452 453 /* Changing between GPU and panel scaling requires a full 454 * modeset 455 */ 456 if ((nv_connector->scaling_mode == DRM_MODE_SCALE_NONE) || 457 (value == DRM_MODE_SCALE_NONE)) 458 modeset = true; 459 nv_connector->scaling_mode = value; 460 461 if (connector->encoder && connector->encoder->crtc) 462 nv_crtc = nouveau_crtc(connector->encoder->crtc); 463 if (!nv_crtc) 464 return 0; 465 466 if (modeset || !nv_crtc->set_scale) { 467 ret = drm_crtc_helper_set_mode(&nv_crtc->base, 468 &nv_crtc->base.mode, 469 nv_crtc->base.x, 470 nv_crtc->base.y, NULL); 471 if (!ret) 472 return -EINVAL; 473 } else { 474 ret = nv_crtc->set_scale(nv_crtc, value, true); 475 if (ret) 476 return ret; 477 } 478 479 return 0; 480 } 481 482 /* Dithering */ 483 if (property == dev->mode_config.dithering_mode_property) { 484 struct nouveau_crtc *nv_crtc = NULL; 485 486 if (value == DRM_MODE_DITHERING_ON) 487 nv_connector->use_dithering = true; 488 else 489 nv_connector->use_dithering = false; 490 491 if (connector->encoder && connector->encoder->crtc) 492 nv_crtc = nouveau_crtc(connector->encoder->crtc); 493 494 if (!nv_crtc || !nv_crtc->set_dither) 495 return 0; 496 497 return nv_crtc->set_dither(nv_crtc, nv_connector->use_dithering, 498 true); 499 } 500 501 if (nv_encoder && nv_encoder->dcb->type == OUTPUT_TV) 502 return get_slave_funcs(encoder)->set_property( 503 encoder, connector, property, value); 504 505 return -EINVAL; 506 } 507 508 static struct drm_display_mode * 509 nouveau_connector_native_mode(struct drm_connector *connector) 510 { 511 struct drm_connector_helper_funcs *helper = connector->helper_private; 512 struct nouveau_connector *nv_connector = nouveau_connector(connector); 513 struct drm_device *dev = connector->dev; 514 struct drm_display_mode *mode, *largest = NULL; 515 int high_w = 0, high_h = 0, high_v = 0; 516 517 list_for_each_entry(mode, &nv_connector->base.probed_modes, head) { 518 mode->vrefresh = drm_mode_vrefresh(mode); 519 if (helper->mode_valid(connector, mode) != MODE_OK || 520 (mode->flags & DRM_MODE_FLAG_INTERLACE)) 521 continue; 522 523 /* Use preferred mode if there is one.. */ 524 if (mode->type & DRM_MODE_TYPE_PREFERRED) { 525 NV_DEBUG_KMS(dev, "native mode from preferred\n"); 526 return drm_mode_duplicate(dev, mode); 527 } 528 529 /* Otherwise, take the resolution with the largest width, then 530 * height, then vertical refresh 531 */ 532 if (mode->hdisplay < high_w) 533 continue; 534 535 if (mode->hdisplay == high_w && mode->vdisplay < high_h) 536 continue; 537 538 if (mode->hdisplay == high_w && mode->vdisplay == high_h && 539 mode->vrefresh < high_v) 540 continue; 541 542 high_w = mode->hdisplay; 543 high_h = mode->vdisplay; 544 high_v = mode->vrefresh; 545 largest = mode; 546 } 547 548 NV_DEBUG_KMS(dev, "native mode from largest: %dx%d@%d\n", 549 high_w, high_h, high_v); 550 return largest ? drm_mode_duplicate(dev, largest) : NULL; 551 } 552 553 struct moderec { 554 int hdisplay; 555 int vdisplay; 556 }; 557 558 static struct moderec scaler_modes[] = { 559 { 1920, 1200 }, 560 { 1920, 1080 }, 561 { 1680, 1050 }, 562 { 1600, 1200 }, 563 { 1400, 1050 }, 564 { 1280, 1024 }, 565 { 1280, 960 }, 566 { 1152, 864 }, 567 { 1024, 768 }, 568 { 800, 600 }, 569 { 720, 400 }, 570 { 640, 480 }, 571 { 640, 400 }, 572 { 640, 350 }, 573 {} 574 }; 575 576 static int 577 nouveau_connector_scaler_modes_add(struct drm_connector *connector) 578 { 579 struct nouveau_connector *nv_connector = nouveau_connector(connector); 580 struct drm_display_mode *native = nv_connector->native_mode, *m; 581 struct drm_device *dev = connector->dev; 582 struct moderec *mode = &scaler_modes[0]; 583 int modes = 0; 584 585 if (!native) 586 return 0; 587 588 while (mode->hdisplay) { 589 if (mode->hdisplay <= native->hdisplay && 590 mode->vdisplay <= native->vdisplay) { 591 m = drm_cvt_mode(dev, mode->hdisplay, mode->vdisplay, 592 drm_mode_vrefresh(native), false, 593 false, false); 594 if (!m) 595 continue; 596 597 m->type |= DRM_MODE_TYPE_DRIVER; 598 599 drm_mode_probed_add(connector, m); 600 modes++; 601 } 602 603 mode++; 604 } 605 606 return modes; 607 } 608 609 static int 610 nouveau_connector_get_modes(struct drm_connector *connector) 611 { 612 struct drm_device *dev = connector->dev; 613 struct drm_nouveau_private *dev_priv = dev->dev_private; 614 struct nouveau_connector *nv_connector = nouveau_connector(connector); 615 struct nouveau_encoder *nv_encoder = nv_connector->detected_encoder; 616 struct drm_encoder *encoder = to_drm_encoder(nv_encoder); 617 int ret = 0; 618 619 /* destroy the native mode, the attached monitor could have changed. 620 */ 621 if (nv_connector->native_mode) { 622 drm_mode_destroy(dev, nv_connector->native_mode); 623 nv_connector->native_mode = NULL; 624 } 625 626 if (nv_connector->edid) 627 ret = drm_add_edid_modes(connector, nv_connector->edid); 628 else 629 if (nv_encoder->dcb->type == OUTPUT_LVDS && 630 (nv_encoder->dcb->lvdsconf.use_straps_for_mode || 631 dev_priv->vbios.fp_no_ddc) && nouveau_bios_fp_mode(dev, NULL)) { 632 struct drm_display_mode mode; 633 634 nouveau_bios_fp_mode(dev, &mode); 635 nv_connector->native_mode = drm_mode_duplicate(dev, &mode); 636 } 637 638 /* Find the native mode if this is a digital panel, if we didn't 639 * find any modes through DDC previously add the native mode to 640 * the list of modes. 641 */ 642 if (!nv_connector->native_mode) 643 nv_connector->native_mode = 644 nouveau_connector_native_mode(connector); 645 if (ret == 0 && nv_connector->native_mode) { 646 struct drm_display_mode *mode; 647 648 mode = drm_mode_duplicate(dev, nv_connector->native_mode); 649 drm_mode_probed_add(connector, mode); 650 ret = 1; 651 } 652 653 if (nv_encoder->dcb->type == OUTPUT_TV) 654 ret = get_slave_funcs(encoder)->get_modes(encoder, connector); 655 656 if (nv_connector->dcb->type == DCB_CONNECTOR_LVDS || 657 nv_connector->dcb->type == DCB_CONNECTOR_LVDS_SPWG || 658 nv_connector->dcb->type == DCB_CONNECTOR_eDP) 659 ret += nouveau_connector_scaler_modes_add(connector); 660 661 return ret; 662 } 663 664 static unsigned 665 get_tmds_link_bandwidth(struct drm_connector *connector) 666 { 667 struct nouveau_connector *nv_connector = nouveau_connector(connector); 668 struct drm_nouveau_private *dev_priv = connector->dev->dev_private; 669 struct dcb_entry *dcb = nv_connector->detected_encoder->dcb; 670 671 if (dcb->location != DCB_LOC_ON_CHIP || 672 dev_priv->chipset >= 0x46) 673 return 165000; 674 else if (dev_priv->chipset >= 0x40) 675 return 155000; 676 else if (dev_priv->chipset >= 0x18) 677 return 135000; 678 else 679 return 112000; 680 } 681 682 static int 683 nouveau_connector_mode_valid(struct drm_connector *connector, 684 struct drm_display_mode *mode) 685 { 686 struct nouveau_connector *nv_connector = nouveau_connector(connector); 687 struct nouveau_encoder *nv_encoder = nv_connector->detected_encoder; 688 struct drm_encoder *encoder = to_drm_encoder(nv_encoder); 689 unsigned min_clock = 25000, max_clock = min_clock; 690 unsigned clock = mode->clock; 691 692 switch (nv_encoder->dcb->type) { 693 case OUTPUT_LVDS: 694 if (nv_connector->native_mode && 695 (mode->hdisplay > nv_connector->native_mode->hdisplay || 696 mode->vdisplay > nv_connector->native_mode->vdisplay)) 697 return MODE_PANEL; 698 699 min_clock = 0; 700 max_clock = 400000; 701 break; 702 case OUTPUT_TMDS: 703 max_clock = get_tmds_link_bandwidth(connector); 704 if (nouveau_duallink && nv_encoder->dcb->duallink_possible) 705 max_clock *= 2; 706 break; 707 case OUTPUT_ANALOG: 708 max_clock = nv_encoder->dcb->crtconf.maxfreq; 709 if (!max_clock) 710 max_clock = 350000; 711 break; 712 case OUTPUT_TV: 713 return get_slave_funcs(encoder)->mode_valid(encoder, mode); 714 case OUTPUT_DP: 715 if (nv_encoder->dp.link_bw == DP_LINK_BW_2_7) 716 max_clock = nv_encoder->dp.link_nr * 270000; 717 else 718 max_clock = nv_encoder->dp.link_nr * 162000; 719 720 clock = clock * nouveau_connector_bpp(connector) / 8; 721 break; 722 default: 723 BUG_ON(1); 724 return MODE_BAD; 725 } 726 727 if (clock < min_clock) 728 return MODE_CLOCK_LOW; 729 730 if (clock > max_clock) 731 return MODE_CLOCK_HIGH; 732 733 return MODE_OK; 734 } 735 736 static struct drm_encoder * 737 nouveau_connector_best_encoder(struct drm_connector *connector) 738 { 739 struct nouveau_connector *nv_connector = nouveau_connector(connector); 740 741 if (nv_connector->detected_encoder) 742 return to_drm_encoder(nv_connector->detected_encoder); 743 744 return NULL; 745 } 746 747 static const struct drm_connector_helper_funcs 748 nouveau_connector_helper_funcs = { 749 .get_modes = nouveau_connector_get_modes, 750 .mode_valid = nouveau_connector_mode_valid, 751 .best_encoder = nouveau_connector_best_encoder, 752 }; 753 754 static const struct drm_connector_funcs 755 nouveau_connector_funcs = { 756 .dpms = drm_helper_connector_dpms, 757 .save = NULL, 758 .restore = NULL, 759 .detect = nouveau_connector_detect, 760 .destroy = nouveau_connector_destroy, 761 .fill_modes = drm_helper_probe_single_connector_modes, 762 .set_property = nouveau_connector_set_property, 763 .force = nouveau_connector_force 764 }; 765 766 static const struct drm_connector_funcs 767 nouveau_connector_funcs_lvds = { 768 .dpms = drm_helper_connector_dpms, 769 .save = NULL, 770 .restore = NULL, 771 .detect = nouveau_connector_detect_lvds, 772 .destroy = nouveau_connector_destroy, 773 .fill_modes = drm_helper_probe_single_connector_modes, 774 .set_property = nouveau_connector_set_property, 775 .force = nouveau_connector_force 776 }; 777 778 struct drm_connector * 779 nouveau_connector_create(struct drm_device *dev, int index) 780 { 781 const struct drm_connector_funcs *funcs = &nouveau_connector_funcs; 782 struct drm_nouveau_private *dev_priv = dev->dev_private; 783 struct nouveau_gpio_engine *pgpio = &dev_priv->engine.gpio; 784 struct nouveau_connector *nv_connector = NULL; 785 struct dcb_connector_table_entry *dcb = NULL; 786 struct drm_connector *connector; 787 int type, ret = 0; 788 789 NV_DEBUG_KMS(dev, "\n"); 790 791 if (index >= dev_priv->vbios.dcb.connector.entries) 792 return ERR_PTR(-EINVAL); 793 794 dcb = &dev_priv->vbios.dcb.connector.entry[index]; 795 if (dcb->drm) 796 return dcb->drm; 797 798 switch (dcb->type) { 799 case DCB_CONNECTOR_VGA: 800 type = DRM_MODE_CONNECTOR_VGA; 801 break; 802 case DCB_CONNECTOR_TV_0: 803 case DCB_CONNECTOR_TV_1: 804 case DCB_CONNECTOR_TV_3: 805 type = DRM_MODE_CONNECTOR_TV; 806 break; 807 case DCB_CONNECTOR_DVI_I: 808 type = DRM_MODE_CONNECTOR_DVII; 809 break; 810 case DCB_CONNECTOR_DVI_D: 811 type = DRM_MODE_CONNECTOR_DVID; 812 break; 813 case DCB_CONNECTOR_HDMI_0: 814 case DCB_CONNECTOR_HDMI_1: 815 type = DRM_MODE_CONNECTOR_HDMIA; 816 break; 817 case DCB_CONNECTOR_LVDS: 818 case DCB_CONNECTOR_LVDS_SPWG: 819 type = DRM_MODE_CONNECTOR_LVDS; 820 funcs = &nouveau_connector_funcs_lvds; 821 break; 822 case DCB_CONNECTOR_DP: 823 type = DRM_MODE_CONNECTOR_DisplayPort; 824 break; 825 case DCB_CONNECTOR_eDP: 826 type = DRM_MODE_CONNECTOR_eDP; 827 break; 828 default: 829 NV_ERROR(dev, "unknown connector type: 0x%02x!!\n", dcb->type); 830 return ERR_PTR(-EINVAL); 831 } 832 833 nv_connector = kzalloc(sizeof(*nv_connector), GFP_KERNEL); 834 if (!nv_connector) 835 return ERR_PTR(-ENOMEM); 836 nv_connector->dcb = dcb; 837 connector = &nv_connector->base; 838 839 /* defaults, will get overridden in detect() */ 840 connector->interlace_allowed = false; 841 connector->doublescan_allowed = false; 842 843 drm_connector_init(dev, connector, funcs, type); 844 drm_connector_helper_add(connector, &nouveau_connector_helper_funcs); 845 846 /* Check if we need dithering enabled */ 847 if (connector->connector_type == DRM_MODE_CONNECTOR_LVDS) { 848 bool dummy, is_24bit = false; 849 850 ret = nouveau_bios_parse_lvds_table(dev, 0, &dummy, &is_24bit); 851 if (ret) { 852 NV_ERROR(dev, "Error parsing LVDS table, disabling " 853 "LVDS\n"); 854 goto fail; 855 } 856 857 nv_connector->use_dithering = !is_24bit; 858 } 859 860 /* Init DVI-I specific properties */ 861 if (dcb->type == DCB_CONNECTOR_DVI_I) { 862 drm_mode_create_dvi_i_properties(dev); 863 drm_connector_attach_property(connector, dev->mode_config.dvi_i_subconnector_property, 0); 864 drm_connector_attach_property(connector, dev->mode_config.dvi_i_select_subconnector_property, 0); 865 } 866 867 switch (dcb->type) { 868 case DCB_CONNECTOR_VGA: 869 if (dev_priv->card_type >= NV_50) { 870 drm_connector_attach_property(connector, 871 dev->mode_config.scaling_mode_property, 872 nv_connector->scaling_mode); 873 } 874 connector->polled = DRM_CONNECTOR_POLL_CONNECT; 875 /* fall-through */ 876 case DCB_CONNECTOR_TV_0: 877 case DCB_CONNECTOR_TV_1: 878 case DCB_CONNECTOR_TV_3: 879 nv_connector->scaling_mode = DRM_MODE_SCALE_NONE; 880 break; 881 default: 882 nv_connector->scaling_mode = DRM_MODE_SCALE_FULLSCREEN; 883 884 drm_connector_attach_property(connector, 885 dev->mode_config.scaling_mode_property, 886 nv_connector->scaling_mode); 887 drm_connector_attach_property(connector, 888 dev->mode_config.dithering_mode_property, 889 nv_connector->use_dithering ? 890 DRM_MODE_DITHERING_ON : DRM_MODE_DITHERING_OFF); 891 892 if (connector->connector_type != DRM_MODE_CONNECTOR_LVDS) { 893 if (dev_priv->card_type >= NV_50) 894 connector->polled = DRM_CONNECTOR_POLL_HPD; 895 else 896 connector->polled = DRM_CONNECTOR_POLL_CONNECT; 897 } 898 break; 899 } 900 901 if (pgpio->irq_register) { 902 pgpio->irq_register(dev, nv_connector->dcb->gpio_tag, 903 nouveau_connector_hotplug, connector); 904 } 905 906 drm_sysfs_connector_add(connector); 907 908 if (connector->connector_type == DRM_MODE_CONNECTOR_LVDS || 909 connector->connector_type == DRM_MODE_CONNECTOR_eDP) 910 nouveau_backlight_init(connector); 911 912 dcb->drm = connector; 913 return dcb->drm; 914 915 fail: 916 drm_connector_cleanup(connector); 917 kfree(connector); 918 return ERR_PTR(ret); 919 920 } 921 922 static void 923 nouveau_connector_hotplug(void *data, int plugged) 924 { 925 struct drm_connector *connector = data; 926 struct drm_device *dev = connector->dev; 927 928 NV_INFO(dev, "%splugged %s\n", plugged ? "" : "un", 929 drm_get_connector_name(connector)); 930 931 if (connector->encoder && connector->encoder->crtc && 932 connector->encoder->crtc->enabled) { 933 struct nouveau_encoder *nv_encoder = nouveau_encoder(connector->encoder); 934 struct drm_encoder_helper_funcs *helper = 935 connector->encoder->helper_private; 936 937 if (nv_encoder->dcb->type == OUTPUT_DP) { 938 if (plugged) 939 helper->dpms(connector->encoder, DRM_MODE_DPMS_ON); 940 else 941 helper->dpms(connector->encoder, DRM_MODE_DPMS_OFF); 942 } 943 } 944 945 drm_helper_hpd_irq_event(dev); 946 } 947