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_gpio.h" 39 #include "nouveau_hw.h" 40 41 static void nouveau_connector_hotplug(void *, int); 42 43 struct nouveau_encoder * 44 find_encoder(struct drm_connector *connector, int type) 45 { 46 struct drm_device *dev = connector->dev; 47 struct nouveau_encoder *nv_encoder; 48 struct drm_mode_object *obj; 49 int i, id; 50 51 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) { 52 id = connector->encoder_ids[i]; 53 if (!id) 54 break; 55 56 obj = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_ENCODER); 57 if (!obj) 58 continue; 59 nv_encoder = nouveau_encoder(obj_to_encoder(obj)); 60 61 if (type == OUTPUT_ANY || nv_encoder->dcb->type == type) 62 return nv_encoder; 63 } 64 65 return NULL; 66 } 67 68 struct nouveau_connector * 69 nouveau_encoder_connector_get(struct nouveau_encoder *encoder) 70 { 71 struct drm_device *dev = to_drm_encoder(encoder)->dev; 72 struct drm_connector *drm_connector; 73 74 list_for_each_entry(drm_connector, &dev->mode_config.connector_list, head) { 75 if (drm_connector->encoder == to_drm_encoder(encoder)) 76 return nouveau_connector(drm_connector); 77 } 78 79 return NULL; 80 } 81 82 static void 83 nouveau_connector_destroy(struct drm_connector *connector) 84 { 85 struct nouveau_connector *nv_connector = nouveau_connector(connector); 86 struct drm_nouveau_private *dev_priv; 87 struct drm_device *dev; 88 89 if (!nv_connector) 90 return; 91 92 dev = nv_connector->base.dev; 93 dev_priv = dev->dev_private; 94 NV_DEBUG_KMS(dev, "\n"); 95 96 if (nv_connector->hpd != DCB_GPIO_UNUSED) { 97 nouveau_gpio_isr_del(dev, 0, nv_connector->hpd, 0xff, 98 nouveau_connector_hotplug, connector); 99 } 100 101 kfree(nv_connector->edid); 102 drm_sysfs_connector_remove(connector); 103 drm_connector_cleanup(connector); 104 kfree(connector); 105 } 106 107 static struct nouveau_i2c_chan * 108 nouveau_connector_ddc_detect(struct drm_connector *connector, 109 struct nouveau_encoder **pnv_encoder) 110 { 111 struct drm_device *dev = connector->dev; 112 int i; 113 114 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) { 115 struct nouveau_i2c_chan *i2c = NULL; 116 struct nouveau_encoder *nv_encoder; 117 struct drm_mode_object *obj; 118 int id; 119 120 id = connector->encoder_ids[i]; 121 if (!id) 122 break; 123 124 obj = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_ENCODER); 125 if (!obj) 126 continue; 127 nv_encoder = nouveau_encoder(obj_to_encoder(obj)); 128 129 if (nv_encoder->dcb->i2c_index < 0xf) 130 i2c = nouveau_i2c_find(dev, nv_encoder->dcb->i2c_index); 131 132 if (i2c && nouveau_probe_i2c_addr(i2c, 0x50)) { 133 *pnv_encoder = nv_encoder; 134 return i2c; 135 } 136 } 137 138 return NULL; 139 } 140 141 static struct nouveau_encoder * 142 nouveau_connector_of_detect(struct drm_connector *connector) 143 { 144 #ifdef __powerpc__ 145 struct drm_device *dev = connector->dev; 146 struct nouveau_connector *nv_connector = nouveau_connector(connector); 147 struct nouveau_encoder *nv_encoder; 148 struct device_node *cn, *dn = pci_device_to_OF_node(dev->pdev); 149 150 if (!dn || 151 !((nv_encoder = find_encoder(connector, OUTPUT_TMDS)) || 152 (nv_encoder = find_encoder(connector, OUTPUT_ANALOG)))) 153 return NULL; 154 155 for_each_child_of_node(dn, cn) { 156 const char *name = of_get_property(cn, "name", NULL); 157 const void *edid = of_get_property(cn, "EDID", NULL); 158 int idx = name ? name[strlen(name) - 1] - 'A' : 0; 159 160 if (nv_encoder->dcb->i2c_index == idx && edid) { 161 nv_connector->edid = 162 kmemdup(edid, EDID_LENGTH, GFP_KERNEL); 163 of_node_put(cn); 164 return nv_encoder; 165 } 166 } 167 #endif 168 return NULL; 169 } 170 171 static void 172 nouveau_connector_set_encoder(struct drm_connector *connector, 173 struct nouveau_encoder *nv_encoder) 174 { 175 struct nouveau_connector *nv_connector = nouveau_connector(connector); 176 struct drm_nouveau_private *dev_priv = connector->dev->dev_private; 177 struct drm_device *dev = connector->dev; 178 179 if (nv_connector->detected_encoder == nv_encoder) 180 return; 181 nv_connector->detected_encoder = nv_encoder; 182 183 if (dev_priv->card_type >= NV_50) { 184 connector->interlace_allowed = true; 185 connector->doublescan_allowed = true; 186 } else 187 if (nv_encoder->dcb->type == OUTPUT_LVDS || 188 nv_encoder->dcb->type == OUTPUT_TMDS) { 189 connector->doublescan_allowed = false; 190 connector->interlace_allowed = false; 191 } else { 192 connector->doublescan_allowed = true; 193 if (dev_priv->card_type == NV_20 || 194 (dev_priv->card_type == NV_10 && 195 (dev->pci_device & 0x0ff0) != 0x0100 && 196 (dev->pci_device & 0x0ff0) != 0x0150)) 197 /* HW is broken */ 198 connector->interlace_allowed = false; 199 else 200 connector->interlace_allowed = true; 201 } 202 203 if (nv_connector->type == DCB_CONNECTOR_DVI_I) { 204 drm_connector_property_set_value(connector, 205 dev->mode_config.dvi_i_subconnector_property, 206 nv_encoder->dcb->type == OUTPUT_TMDS ? 207 DRM_MODE_SUBCONNECTOR_DVID : 208 DRM_MODE_SUBCONNECTOR_DVIA); 209 } 210 } 211 212 static enum drm_connector_status 213 nouveau_connector_detect(struct drm_connector *connector, bool force) 214 { 215 struct drm_device *dev = connector->dev; 216 struct nouveau_connector *nv_connector = nouveau_connector(connector); 217 struct nouveau_encoder *nv_encoder = NULL; 218 struct nouveau_encoder *nv_partner; 219 struct nouveau_i2c_chan *i2c; 220 int type; 221 222 /* Cleanup the previous EDID block. */ 223 if (nv_connector->edid) { 224 drm_mode_connector_update_edid_property(connector, NULL); 225 kfree(nv_connector->edid); 226 nv_connector->edid = NULL; 227 } 228 229 i2c = nouveau_connector_ddc_detect(connector, &nv_encoder); 230 if (i2c) { 231 nv_connector->edid = drm_get_edid(connector, &i2c->adapter); 232 drm_mode_connector_update_edid_property(connector, 233 nv_connector->edid); 234 if (!nv_connector->edid) { 235 NV_ERROR(dev, "DDC responded, but no EDID for %s\n", 236 drm_get_connector_name(connector)); 237 goto detect_analog; 238 } 239 240 if (nv_encoder->dcb->type == OUTPUT_DP && 241 !nouveau_dp_detect(to_drm_encoder(nv_encoder))) { 242 NV_ERROR(dev, "Detected %s, but failed init\n", 243 drm_get_connector_name(connector)); 244 return connector_status_disconnected; 245 } 246 247 /* Override encoder type for DVI-I based on whether EDID 248 * says the display is digital or analog, both use the 249 * same i2c channel so the value returned from ddc_detect 250 * isn't necessarily correct. 251 */ 252 nv_partner = NULL; 253 if (nv_encoder->dcb->type == OUTPUT_TMDS) 254 nv_partner = find_encoder(connector, OUTPUT_ANALOG); 255 if (nv_encoder->dcb->type == OUTPUT_ANALOG) 256 nv_partner = find_encoder(connector, OUTPUT_TMDS); 257 258 if (nv_partner && ((nv_encoder->dcb->type == OUTPUT_ANALOG && 259 nv_partner->dcb->type == OUTPUT_TMDS) || 260 (nv_encoder->dcb->type == OUTPUT_TMDS && 261 nv_partner->dcb->type == OUTPUT_ANALOG))) { 262 if (nv_connector->edid->input & DRM_EDID_INPUT_DIGITAL) 263 type = OUTPUT_TMDS; 264 else 265 type = OUTPUT_ANALOG; 266 267 nv_encoder = find_encoder(connector, type); 268 } 269 270 nouveau_connector_set_encoder(connector, nv_encoder); 271 return connector_status_connected; 272 } 273 274 nv_encoder = nouveau_connector_of_detect(connector); 275 if (nv_encoder) { 276 nouveau_connector_set_encoder(connector, nv_encoder); 277 return connector_status_connected; 278 } 279 280 detect_analog: 281 nv_encoder = find_encoder(connector, OUTPUT_ANALOG); 282 if (!nv_encoder && !nouveau_tv_disable) 283 nv_encoder = find_encoder(connector, OUTPUT_TV); 284 if (nv_encoder && force) { 285 struct drm_encoder *encoder = to_drm_encoder(nv_encoder); 286 struct drm_encoder_helper_funcs *helper = 287 encoder->helper_private; 288 289 if (helper->detect(encoder, connector) == 290 connector_status_connected) { 291 nouveau_connector_set_encoder(connector, nv_encoder); 292 return connector_status_connected; 293 } 294 295 } 296 297 return connector_status_disconnected; 298 } 299 300 static enum drm_connector_status 301 nouveau_connector_detect_lvds(struct drm_connector *connector, bool force) 302 { 303 struct drm_device *dev = connector->dev; 304 struct drm_nouveau_private *dev_priv = dev->dev_private; 305 struct nouveau_connector *nv_connector = nouveau_connector(connector); 306 struct nouveau_encoder *nv_encoder = NULL; 307 enum drm_connector_status status = connector_status_disconnected; 308 309 /* Cleanup the previous EDID block. */ 310 if (nv_connector->edid) { 311 drm_mode_connector_update_edid_property(connector, NULL); 312 kfree(nv_connector->edid); 313 nv_connector->edid = NULL; 314 } 315 316 nv_encoder = find_encoder(connector, OUTPUT_LVDS); 317 if (!nv_encoder) 318 return connector_status_disconnected; 319 320 /* Try retrieving EDID via DDC */ 321 if (!dev_priv->vbios.fp_no_ddc) { 322 status = nouveau_connector_detect(connector, force); 323 if (status == connector_status_connected) 324 goto out; 325 } 326 327 /* On some laptops (Sony, i'm looking at you) there appears to 328 * be no direct way of accessing the panel's EDID. The only 329 * option available to us appears to be to ask ACPI for help.. 330 * 331 * It's important this check's before trying straps, one of the 332 * said manufacturer's laptops are configured in such a way 333 * the nouveau decides an entry in the VBIOS FP mode table is 334 * valid - it's not (rh#613284) 335 */ 336 if (nv_encoder->dcb->lvdsconf.use_acpi_for_edid) { 337 if (!nouveau_acpi_edid(dev, connector)) { 338 status = connector_status_connected; 339 goto out; 340 } 341 } 342 343 /* If no EDID found above, and the VBIOS indicates a hardcoded 344 * modeline is avalilable for the panel, set it as the panel's 345 * native mode and exit. 346 */ 347 if (nouveau_bios_fp_mode(dev, NULL) && (dev_priv->vbios.fp_no_ddc || 348 nv_encoder->dcb->lvdsconf.use_straps_for_mode)) { 349 status = connector_status_connected; 350 goto out; 351 } 352 353 /* Still nothing, some VBIOS images have a hardcoded EDID block 354 * stored for the panel stored in them. 355 */ 356 if (!dev_priv->vbios.fp_no_ddc) { 357 struct edid *edid = 358 (struct edid *)nouveau_bios_embedded_edid(dev); 359 if (edid) { 360 nv_connector->edid = kmalloc(EDID_LENGTH, GFP_KERNEL); 361 *(nv_connector->edid) = *edid; 362 status = connector_status_connected; 363 } 364 } 365 366 out: 367 #if defined(CONFIG_ACPI_BUTTON) || \ 368 (defined(CONFIG_ACPI_BUTTON_MODULE) && defined(MODULE)) 369 if (status == connector_status_connected && 370 !nouveau_ignorelid && !acpi_lid_open()) 371 status = connector_status_unknown; 372 #endif 373 374 drm_mode_connector_update_edid_property(connector, nv_connector->edid); 375 nouveau_connector_set_encoder(connector, nv_encoder); 376 return status; 377 } 378 379 static void 380 nouveau_connector_force(struct drm_connector *connector) 381 { 382 struct nouveau_connector *nv_connector = nouveau_connector(connector); 383 struct nouveau_encoder *nv_encoder; 384 int type; 385 386 if (nv_connector->type == DCB_CONNECTOR_DVI_I) { 387 if (connector->force == DRM_FORCE_ON_DIGITAL) 388 type = OUTPUT_TMDS; 389 else 390 type = OUTPUT_ANALOG; 391 } else 392 type = OUTPUT_ANY; 393 394 nv_encoder = find_encoder(connector, type); 395 if (!nv_encoder) { 396 NV_ERROR(connector->dev, "can't find encoder to force %s on!\n", 397 drm_get_connector_name(connector)); 398 connector->status = connector_status_disconnected; 399 return; 400 } 401 402 nouveau_connector_set_encoder(connector, nv_encoder); 403 } 404 405 static int 406 nouveau_connector_set_property(struct drm_connector *connector, 407 struct drm_property *property, uint64_t value) 408 { 409 struct drm_nouveau_private *dev_priv = connector->dev->dev_private; 410 struct nouveau_display_engine *disp = &dev_priv->engine.display; 411 struct nouveau_connector *nv_connector = nouveau_connector(connector); 412 struct nouveau_encoder *nv_encoder = nv_connector->detected_encoder; 413 struct drm_encoder *encoder = to_drm_encoder(nv_encoder); 414 struct drm_device *dev = connector->dev; 415 struct nouveau_crtc *nv_crtc; 416 int ret; 417 418 nv_crtc = NULL; 419 if (connector->encoder && connector->encoder->crtc) 420 nv_crtc = nouveau_crtc(connector->encoder->crtc); 421 422 /* Scaling mode */ 423 if (property == dev->mode_config.scaling_mode_property) { 424 bool modeset = false; 425 426 switch (value) { 427 case DRM_MODE_SCALE_NONE: 428 case DRM_MODE_SCALE_FULLSCREEN: 429 case DRM_MODE_SCALE_CENTER: 430 case DRM_MODE_SCALE_ASPECT: 431 break; 432 default: 433 return -EINVAL; 434 } 435 436 /* LVDS always needs gpu scaling */ 437 if (connector->connector_type == DRM_MODE_CONNECTOR_LVDS && 438 value == DRM_MODE_SCALE_NONE) 439 return -EINVAL; 440 441 /* Changing between GPU and panel scaling requires a full 442 * modeset 443 */ 444 if ((nv_connector->scaling_mode == DRM_MODE_SCALE_NONE) || 445 (value == DRM_MODE_SCALE_NONE)) 446 modeset = true; 447 nv_connector->scaling_mode = value; 448 449 if (!nv_crtc) 450 return 0; 451 452 if (modeset || !nv_crtc->set_scale) { 453 ret = drm_crtc_helper_set_mode(&nv_crtc->base, 454 &nv_crtc->base.mode, 455 nv_crtc->base.x, 456 nv_crtc->base.y, NULL); 457 if (!ret) 458 return -EINVAL; 459 } else { 460 ret = nv_crtc->set_scale(nv_crtc, true); 461 if (ret) 462 return ret; 463 } 464 465 return 0; 466 } 467 468 /* Underscan */ 469 if (property == disp->underscan_property) { 470 if (nv_connector->underscan != value) { 471 nv_connector->underscan = value; 472 if (!nv_crtc || !nv_crtc->set_scale) 473 return 0; 474 475 return nv_crtc->set_scale(nv_crtc, true); 476 } 477 478 return 0; 479 } 480 481 if (property == disp->underscan_hborder_property) { 482 if (nv_connector->underscan_hborder != value) { 483 nv_connector->underscan_hborder = value; 484 if (!nv_crtc || !nv_crtc->set_scale) 485 return 0; 486 487 return nv_crtc->set_scale(nv_crtc, true); 488 } 489 490 return 0; 491 } 492 493 if (property == disp->underscan_vborder_property) { 494 if (nv_connector->underscan_vborder != value) { 495 nv_connector->underscan_vborder = value; 496 if (!nv_crtc || !nv_crtc->set_scale) 497 return 0; 498 499 return nv_crtc->set_scale(nv_crtc, true); 500 } 501 502 return 0; 503 } 504 505 /* Dithering */ 506 if (property == disp->dithering_mode) { 507 nv_connector->dithering_mode = value; 508 if (!nv_crtc || !nv_crtc->set_dither) 509 return 0; 510 511 return nv_crtc->set_dither(nv_crtc, true); 512 } 513 514 if (property == disp->dithering_depth) { 515 nv_connector->dithering_depth = value; 516 if (!nv_crtc || !nv_crtc->set_dither) 517 return 0; 518 519 return nv_crtc->set_dither(nv_crtc, true); 520 } 521 522 if (nv_crtc && nv_crtc->set_color_vibrance) { 523 /* Hue */ 524 if (property == disp->vibrant_hue_property) { 525 nv_crtc->vibrant_hue = value - 90; 526 return nv_crtc->set_color_vibrance(nv_crtc, true); 527 } 528 /* Saturation */ 529 if (property == disp->color_vibrance_property) { 530 nv_crtc->color_vibrance = value - 100; 531 return nv_crtc->set_color_vibrance(nv_crtc, true); 532 } 533 } 534 535 if (nv_encoder && nv_encoder->dcb->type == OUTPUT_TV) 536 return get_slave_funcs(encoder)->set_property( 537 encoder, connector, property, value); 538 539 return -EINVAL; 540 } 541 542 static struct drm_display_mode * 543 nouveau_connector_native_mode(struct drm_connector *connector) 544 { 545 struct drm_connector_helper_funcs *helper = connector->helper_private; 546 struct nouveau_connector *nv_connector = nouveau_connector(connector); 547 struct drm_device *dev = connector->dev; 548 struct drm_display_mode *mode, *largest = NULL; 549 int high_w = 0, high_h = 0, high_v = 0; 550 551 list_for_each_entry(mode, &nv_connector->base.probed_modes, head) { 552 mode->vrefresh = drm_mode_vrefresh(mode); 553 if (helper->mode_valid(connector, mode) != MODE_OK || 554 (mode->flags & DRM_MODE_FLAG_INTERLACE)) 555 continue; 556 557 /* Use preferred mode if there is one.. */ 558 if (mode->type & DRM_MODE_TYPE_PREFERRED) { 559 NV_DEBUG_KMS(dev, "native mode from preferred\n"); 560 return drm_mode_duplicate(dev, mode); 561 } 562 563 /* Otherwise, take the resolution with the largest width, then 564 * height, then vertical refresh 565 */ 566 if (mode->hdisplay < high_w) 567 continue; 568 569 if (mode->hdisplay == high_w && mode->vdisplay < high_h) 570 continue; 571 572 if (mode->hdisplay == high_w && mode->vdisplay == high_h && 573 mode->vrefresh < high_v) 574 continue; 575 576 high_w = mode->hdisplay; 577 high_h = mode->vdisplay; 578 high_v = mode->vrefresh; 579 largest = mode; 580 } 581 582 NV_DEBUG_KMS(dev, "native mode from largest: %dx%d@%d\n", 583 high_w, high_h, high_v); 584 return largest ? drm_mode_duplicate(dev, largest) : NULL; 585 } 586 587 struct moderec { 588 int hdisplay; 589 int vdisplay; 590 }; 591 592 static struct moderec scaler_modes[] = { 593 { 1920, 1200 }, 594 { 1920, 1080 }, 595 { 1680, 1050 }, 596 { 1600, 1200 }, 597 { 1400, 1050 }, 598 { 1280, 1024 }, 599 { 1280, 960 }, 600 { 1152, 864 }, 601 { 1024, 768 }, 602 { 800, 600 }, 603 { 720, 400 }, 604 { 640, 480 }, 605 { 640, 400 }, 606 { 640, 350 }, 607 {} 608 }; 609 610 static int 611 nouveau_connector_scaler_modes_add(struct drm_connector *connector) 612 { 613 struct nouveau_connector *nv_connector = nouveau_connector(connector); 614 struct drm_display_mode *native = nv_connector->native_mode, *m; 615 struct drm_device *dev = connector->dev; 616 struct moderec *mode = &scaler_modes[0]; 617 int modes = 0; 618 619 if (!native) 620 return 0; 621 622 while (mode->hdisplay) { 623 if (mode->hdisplay <= native->hdisplay && 624 mode->vdisplay <= native->vdisplay) { 625 m = drm_cvt_mode(dev, mode->hdisplay, mode->vdisplay, 626 drm_mode_vrefresh(native), false, 627 false, false); 628 if (!m) 629 continue; 630 631 m->type |= DRM_MODE_TYPE_DRIVER; 632 633 drm_mode_probed_add(connector, m); 634 modes++; 635 } 636 637 mode++; 638 } 639 640 return modes; 641 } 642 643 static void 644 nouveau_connector_detect_depth(struct drm_connector *connector) 645 { 646 struct drm_nouveau_private *dev_priv = connector->dev->dev_private; 647 struct nouveau_connector *nv_connector = nouveau_connector(connector); 648 struct nouveau_encoder *nv_encoder = nv_connector->detected_encoder; 649 struct nvbios *bios = &dev_priv->vbios; 650 struct drm_display_mode *mode = nv_connector->native_mode; 651 bool duallink; 652 653 /* if the edid is feeling nice enough to provide this info, use it */ 654 if (nv_connector->edid && connector->display_info.bpc) 655 return; 656 657 /* if not, we're out of options unless we're LVDS, default to 8bpc */ 658 if (nv_encoder->dcb->type != OUTPUT_LVDS) { 659 connector->display_info.bpc = 8; 660 return; 661 } 662 663 connector->display_info.bpc = 6; 664 665 /* LVDS: panel straps */ 666 if (bios->fp_no_ddc) { 667 if (bios->fp.if_is_24bit) 668 connector->display_info.bpc = 8; 669 return; 670 } 671 672 /* LVDS: DDC panel, need to first determine the number of links to 673 * know which if_is_24bit flag to check... 674 */ 675 if (nv_connector->edid && 676 nv_connector->type == DCB_CONNECTOR_LVDS_SPWG) 677 duallink = ((u8 *)nv_connector->edid)[121] == 2; 678 else 679 duallink = mode->clock >= bios->fp.duallink_transition_clk; 680 681 if ((!duallink && (bios->fp.strapless_is_24bit & 1)) || 682 ( duallink && (bios->fp.strapless_is_24bit & 2))) 683 connector->display_info.bpc = 8; 684 } 685 686 static int 687 nouveau_connector_get_modes(struct drm_connector *connector) 688 { 689 struct drm_device *dev = connector->dev; 690 struct drm_nouveau_private *dev_priv = dev->dev_private; 691 struct nouveau_connector *nv_connector = nouveau_connector(connector); 692 struct nouveau_encoder *nv_encoder = nv_connector->detected_encoder; 693 struct drm_encoder *encoder = to_drm_encoder(nv_encoder); 694 int ret = 0; 695 696 /* destroy the native mode, the attached monitor could have changed. 697 */ 698 if (nv_connector->native_mode) { 699 drm_mode_destroy(dev, nv_connector->native_mode); 700 nv_connector->native_mode = NULL; 701 } 702 703 if (nv_connector->edid) 704 ret = drm_add_edid_modes(connector, nv_connector->edid); 705 else 706 if (nv_encoder->dcb->type == OUTPUT_LVDS && 707 (nv_encoder->dcb->lvdsconf.use_straps_for_mode || 708 dev_priv->vbios.fp_no_ddc) && nouveau_bios_fp_mode(dev, NULL)) { 709 struct drm_display_mode mode; 710 711 nouveau_bios_fp_mode(dev, &mode); 712 nv_connector->native_mode = drm_mode_duplicate(dev, &mode); 713 } 714 715 /* Determine display colour depth for everything except LVDS now, 716 * DP requires this before mode_valid() is called. 717 */ 718 if (connector->connector_type != DRM_MODE_CONNECTOR_LVDS) 719 nouveau_connector_detect_depth(connector); 720 721 /* Find the native mode if this is a digital panel, if we didn't 722 * find any modes through DDC previously add the native mode to 723 * the list of modes. 724 */ 725 if (!nv_connector->native_mode) 726 nv_connector->native_mode = 727 nouveau_connector_native_mode(connector); 728 if (ret == 0 && nv_connector->native_mode) { 729 struct drm_display_mode *mode; 730 731 mode = drm_mode_duplicate(dev, nv_connector->native_mode); 732 drm_mode_probed_add(connector, mode); 733 ret = 1; 734 } 735 736 /* Determine LVDS colour depth, must happen after determining 737 * "native" mode as some VBIOS tables require us to use the 738 * pixel clock as part of the lookup... 739 */ 740 if (connector->connector_type == DRM_MODE_CONNECTOR_LVDS) 741 nouveau_connector_detect_depth(connector); 742 743 if (nv_encoder->dcb->type == OUTPUT_TV) 744 ret = get_slave_funcs(encoder)->get_modes(encoder, connector); 745 746 if (nv_connector->type == DCB_CONNECTOR_LVDS || 747 nv_connector->type == DCB_CONNECTOR_LVDS_SPWG || 748 nv_connector->type == DCB_CONNECTOR_eDP) 749 ret += nouveau_connector_scaler_modes_add(connector); 750 751 return ret; 752 } 753 754 static unsigned 755 get_tmds_link_bandwidth(struct drm_connector *connector) 756 { 757 struct nouveau_connector *nv_connector = nouveau_connector(connector); 758 struct drm_nouveau_private *dev_priv = connector->dev->dev_private; 759 struct dcb_entry *dcb = nv_connector->detected_encoder->dcb; 760 761 if (dcb->location != DCB_LOC_ON_CHIP || 762 dev_priv->chipset >= 0x46) 763 return 165000; 764 else if (dev_priv->chipset >= 0x40) 765 return 155000; 766 else if (dev_priv->chipset >= 0x18) 767 return 135000; 768 else 769 return 112000; 770 } 771 772 static int 773 nouveau_connector_mode_valid(struct drm_connector *connector, 774 struct drm_display_mode *mode) 775 { 776 struct nouveau_connector *nv_connector = nouveau_connector(connector); 777 struct nouveau_encoder *nv_encoder = nv_connector->detected_encoder; 778 struct drm_encoder *encoder = to_drm_encoder(nv_encoder); 779 unsigned min_clock = 25000, max_clock = min_clock; 780 unsigned clock = mode->clock; 781 782 switch (nv_encoder->dcb->type) { 783 case OUTPUT_LVDS: 784 if (nv_connector->native_mode && 785 (mode->hdisplay > nv_connector->native_mode->hdisplay || 786 mode->vdisplay > nv_connector->native_mode->vdisplay)) 787 return MODE_PANEL; 788 789 min_clock = 0; 790 max_clock = 400000; 791 break; 792 case OUTPUT_TMDS: 793 max_clock = get_tmds_link_bandwidth(connector); 794 if (nouveau_duallink && nv_encoder->dcb->duallink_possible) 795 max_clock *= 2; 796 break; 797 case OUTPUT_ANALOG: 798 max_clock = nv_encoder->dcb->crtconf.maxfreq; 799 if (!max_clock) 800 max_clock = 350000; 801 break; 802 case OUTPUT_TV: 803 return get_slave_funcs(encoder)->mode_valid(encoder, mode); 804 case OUTPUT_DP: 805 max_clock = nv_encoder->dp.link_nr; 806 max_clock *= nv_encoder->dp.link_bw; 807 clock = clock * (connector->display_info.bpc * 3) / 10; 808 break; 809 default: 810 BUG_ON(1); 811 return MODE_BAD; 812 } 813 814 if (clock < min_clock) 815 return MODE_CLOCK_LOW; 816 817 if (clock > max_clock) 818 return MODE_CLOCK_HIGH; 819 820 return MODE_OK; 821 } 822 823 static struct drm_encoder * 824 nouveau_connector_best_encoder(struct drm_connector *connector) 825 { 826 struct nouveau_connector *nv_connector = nouveau_connector(connector); 827 828 if (nv_connector->detected_encoder) 829 return to_drm_encoder(nv_connector->detected_encoder); 830 831 return NULL; 832 } 833 834 static const struct drm_connector_helper_funcs 835 nouveau_connector_helper_funcs = { 836 .get_modes = nouveau_connector_get_modes, 837 .mode_valid = nouveau_connector_mode_valid, 838 .best_encoder = nouveau_connector_best_encoder, 839 }; 840 841 static const struct drm_connector_funcs 842 nouveau_connector_funcs = { 843 .dpms = drm_helper_connector_dpms, 844 .save = NULL, 845 .restore = NULL, 846 .detect = nouveau_connector_detect, 847 .destroy = nouveau_connector_destroy, 848 .fill_modes = drm_helper_probe_single_connector_modes, 849 .set_property = nouveau_connector_set_property, 850 .force = nouveau_connector_force 851 }; 852 853 static const struct drm_connector_funcs 854 nouveau_connector_funcs_lvds = { 855 .dpms = drm_helper_connector_dpms, 856 .save = NULL, 857 .restore = NULL, 858 .detect = nouveau_connector_detect_lvds, 859 .destroy = nouveau_connector_destroy, 860 .fill_modes = drm_helper_probe_single_connector_modes, 861 .set_property = nouveau_connector_set_property, 862 .force = nouveau_connector_force 863 }; 864 865 static int 866 drm_conntype_from_dcb(enum dcb_connector_type dcb) 867 { 868 switch (dcb) { 869 case DCB_CONNECTOR_VGA : return DRM_MODE_CONNECTOR_VGA; 870 case DCB_CONNECTOR_TV_0 : 871 case DCB_CONNECTOR_TV_1 : 872 case DCB_CONNECTOR_TV_3 : return DRM_MODE_CONNECTOR_TV; 873 case DCB_CONNECTOR_DMS59_0 : 874 case DCB_CONNECTOR_DMS59_1 : 875 case DCB_CONNECTOR_DVI_I : return DRM_MODE_CONNECTOR_DVII; 876 case DCB_CONNECTOR_DVI_D : return DRM_MODE_CONNECTOR_DVID; 877 case DCB_CONNECTOR_LVDS : 878 case DCB_CONNECTOR_LVDS_SPWG: return DRM_MODE_CONNECTOR_LVDS; 879 case DCB_CONNECTOR_DMS59_DP0: 880 case DCB_CONNECTOR_DMS59_DP1: 881 case DCB_CONNECTOR_DP : return DRM_MODE_CONNECTOR_DisplayPort; 882 case DCB_CONNECTOR_eDP : return DRM_MODE_CONNECTOR_eDP; 883 case DCB_CONNECTOR_HDMI_0 : 884 case DCB_CONNECTOR_HDMI_1 : return DRM_MODE_CONNECTOR_HDMIA; 885 default: 886 break; 887 } 888 889 return DRM_MODE_CONNECTOR_Unknown; 890 } 891 892 struct drm_connector * 893 nouveau_connector_create(struct drm_device *dev, int index) 894 { 895 const struct drm_connector_funcs *funcs = &nouveau_connector_funcs; 896 struct drm_nouveau_private *dev_priv = dev->dev_private; 897 struct nouveau_display_engine *disp = &dev_priv->engine.display; 898 struct nouveau_connector *nv_connector = NULL; 899 struct drm_connector *connector; 900 int type, ret = 0; 901 bool dummy; 902 903 NV_DEBUG_KMS(dev, "\n"); 904 905 list_for_each_entry(connector, &dev->mode_config.connector_list, head) { 906 nv_connector = nouveau_connector(connector); 907 if (nv_connector->index == index) 908 return connector; 909 } 910 911 nv_connector = kzalloc(sizeof(*nv_connector), GFP_KERNEL); 912 if (!nv_connector) 913 return ERR_PTR(-ENOMEM); 914 915 connector = &nv_connector->base; 916 nv_connector->index = index; 917 918 /* attempt to parse vbios connector type and hotplug gpio */ 919 nv_connector->dcb = dcb_conn(dev, index); 920 if (nv_connector->dcb) { 921 static const u8 hpd[16] = { 922 0xff, 0x07, 0x08, 0xff, 0xff, 0x51, 0x52, 0xff, 923 0xff, 0xff, 0xff, 0xff, 0xff, 0x5e, 0x5f, 0x60, 924 }; 925 926 u32 entry = ROM16(nv_connector->dcb[0]); 927 if (dcb_conntab(dev)[3] >= 4) 928 entry |= (u32)ROM16(nv_connector->dcb[2]) << 16; 929 930 nv_connector->hpd = ffs((entry & 0x07033000) >> 12); 931 nv_connector->hpd = hpd[nv_connector->hpd]; 932 933 nv_connector->type = nv_connector->dcb[0]; 934 if (drm_conntype_from_dcb(nv_connector->type) == 935 DRM_MODE_CONNECTOR_Unknown) { 936 NV_WARN(dev, "unknown connector type %02x\n", 937 nv_connector->type); 938 nv_connector->type = DCB_CONNECTOR_NONE; 939 } 940 941 /* Gigabyte NX85T */ 942 if (nv_match_device(dev, 0x0421, 0x1458, 0x344c)) { 943 if (nv_connector->type == DCB_CONNECTOR_HDMI_1) 944 nv_connector->type = DCB_CONNECTOR_DVI_I; 945 } 946 947 /* Gigabyte GV-NX86T512H */ 948 if (nv_match_device(dev, 0x0402, 0x1458, 0x3455)) { 949 if (nv_connector->type == DCB_CONNECTOR_HDMI_1) 950 nv_connector->type = DCB_CONNECTOR_DVI_I; 951 } 952 } else { 953 nv_connector->type = DCB_CONNECTOR_NONE; 954 nv_connector->hpd = DCB_GPIO_UNUSED; 955 } 956 957 /* no vbios data, or an unknown dcb connector type - attempt to 958 * figure out something suitable ourselves 959 */ 960 if (nv_connector->type == DCB_CONNECTOR_NONE) { 961 struct drm_nouveau_private *dev_priv = dev->dev_private; 962 struct dcb_table *dcbt = &dev_priv->vbios.dcb; 963 u32 encoders = 0; 964 int i; 965 966 for (i = 0; i < dcbt->entries; i++) { 967 if (dcbt->entry[i].connector == nv_connector->index) 968 encoders |= (1 << dcbt->entry[i].type); 969 } 970 971 if (encoders & (1 << OUTPUT_DP)) { 972 if (encoders & (1 << OUTPUT_TMDS)) 973 nv_connector->type = DCB_CONNECTOR_DP; 974 else 975 nv_connector->type = DCB_CONNECTOR_eDP; 976 } else 977 if (encoders & (1 << OUTPUT_TMDS)) { 978 if (encoders & (1 << OUTPUT_ANALOG)) 979 nv_connector->type = DCB_CONNECTOR_DVI_I; 980 else 981 nv_connector->type = DCB_CONNECTOR_DVI_D; 982 } else 983 if (encoders & (1 << OUTPUT_ANALOG)) { 984 nv_connector->type = DCB_CONNECTOR_VGA; 985 } else 986 if (encoders & (1 << OUTPUT_LVDS)) { 987 nv_connector->type = DCB_CONNECTOR_LVDS; 988 } else 989 if (encoders & (1 << OUTPUT_TV)) { 990 nv_connector->type = DCB_CONNECTOR_TV_0; 991 } 992 } 993 994 type = drm_conntype_from_dcb(nv_connector->type); 995 if (type == DRM_MODE_CONNECTOR_LVDS) { 996 ret = nouveau_bios_parse_lvds_table(dev, 0, &dummy, &dummy); 997 if (ret) { 998 NV_ERROR(dev, "Error parsing LVDS table, disabling\n"); 999 kfree(nv_connector); 1000 return ERR_PTR(ret); 1001 } 1002 1003 funcs = &nouveau_connector_funcs_lvds; 1004 } else { 1005 funcs = &nouveau_connector_funcs; 1006 } 1007 1008 /* defaults, will get overridden in detect() */ 1009 connector->interlace_allowed = false; 1010 connector->doublescan_allowed = false; 1011 1012 drm_connector_init(dev, connector, funcs, type); 1013 drm_connector_helper_add(connector, &nouveau_connector_helper_funcs); 1014 1015 /* Init DVI-I specific properties */ 1016 if (nv_connector->type == DCB_CONNECTOR_DVI_I) 1017 drm_connector_attach_property(connector, dev->mode_config.dvi_i_subconnector_property, 0); 1018 1019 /* Add overscan compensation options to digital outputs */ 1020 if (disp->underscan_property && 1021 (type == DRM_MODE_CONNECTOR_DVID || 1022 type == DRM_MODE_CONNECTOR_DVII || 1023 type == DRM_MODE_CONNECTOR_HDMIA || 1024 type == DRM_MODE_CONNECTOR_DisplayPort)) { 1025 drm_connector_attach_property(connector, 1026 disp->underscan_property, 1027 UNDERSCAN_OFF); 1028 drm_connector_attach_property(connector, 1029 disp->underscan_hborder_property, 1030 0); 1031 drm_connector_attach_property(connector, 1032 disp->underscan_vborder_property, 1033 0); 1034 } 1035 1036 /* Add hue and saturation options */ 1037 if (disp->vibrant_hue_property) 1038 drm_connector_attach_property(connector, 1039 disp->vibrant_hue_property, 1040 90); 1041 if (disp->color_vibrance_property) 1042 drm_connector_attach_property(connector, 1043 disp->color_vibrance_property, 1044 150); 1045 1046 switch (nv_connector->type) { 1047 case DCB_CONNECTOR_VGA: 1048 if (dev_priv->card_type >= NV_50) { 1049 drm_connector_attach_property(connector, 1050 dev->mode_config.scaling_mode_property, 1051 nv_connector->scaling_mode); 1052 } 1053 /* fall-through */ 1054 case DCB_CONNECTOR_TV_0: 1055 case DCB_CONNECTOR_TV_1: 1056 case DCB_CONNECTOR_TV_3: 1057 nv_connector->scaling_mode = DRM_MODE_SCALE_NONE; 1058 break; 1059 default: 1060 nv_connector->scaling_mode = DRM_MODE_SCALE_FULLSCREEN; 1061 1062 drm_connector_attach_property(connector, 1063 dev->mode_config.scaling_mode_property, 1064 nv_connector->scaling_mode); 1065 if (disp->dithering_mode) { 1066 nv_connector->dithering_mode = DITHERING_MODE_AUTO; 1067 drm_connector_attach_property(connector, 1068 disp->dithering_mode, 1069 nv_connector->dithering_mode); 1070 } 1071 if (disp->dithering_depth) { 1072 nv_connector->dithering_depth = DITHERING_DEPTH_AUTO; 1073 drm_connector_attach_property(connector, 1074 disp->dithering_depth, 1075 nv_connector->dithering_depth); 1076 } 1077 break; 1078 } 1079 1080 connector->polled = DRM_CONNECTOR_POLL_CONNECT; 1081 if (nv_connector->hpd != DCB_GPIO_UNUSED) { 1082 ret = nouveau_gpio_isr_add(dev, 0, nv_connector->hpd, 0xff, 1083 nouveau_connector_hotplug, 1084 connector); 1085 if (ret == 0) 1086 connector->polled = DRM_CONNECTOR_POLL_HPD; 1087 } 1088 1089 drm_sysfs_connector_add(connector); 1090 return connector; 1091 } 1092 1093 static void 1094 nouveau_connector_hotplug(void *data, int plugged) 1095 { 1096 struct drm_connector *connector = data; 1097 struct drm_device *dev = connector->dev; 1098 1099 NV_DEBUG(dev, "%splugged %s\n", plugged ? "" : "un", 1100 drm_get_connector_name(connector)); 1101 1102 if (plugged) 1103 drm_helper_connector_dpms(connector, DRM_MODE_DPMS_ON); 1104 else 1105 drm_helper_connector_dpms(connector, DRM_MODE_DPMS_OFF); 1106 1107 drm_helper_hpd_irq_event(dev); 1108 } 1109