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_encoder && nv_encoder->dcb->type == OUTPUT_TV) 523 return get_slave_funcs(encoder)->set_property( 524 encoder, connector, property, value); 525 526 return -EINVAL; 527 } 528 529 static struct drm_display_mode * 530 nouveau_connector_native_mode(struct drm_connector *connector) 531 { 532 struct drm_connector_helper_funcs *helper = connector->helper_private; 533 struct nouveau_connector *nv_connector = nouveau_connector(connector); 534 struct drm_device *dev = connector->dev; 535 struct drm_display_mode *mode, *largest = NULL; 536 int high_w = 0, high_h = 0, high_v = 0; 537 538 list_for_each_entry(mode, &nv_connector->base.probed_modes, head) { 539 mode->vrefresh = drm_mode_vrefresh(mode); 540 if (helper->mode_valid(connector, mode) != MODE_OK || 541 (mode->flags & DRM_MODE_FLAG_INTERLACE)) 542 continue; 543 544 /* Use preferred mode if there is one.. */ 545 if (mode->type & DRM_MODE_TYPE_PREFERRED) { 546 NV_DEBUG_KMS(dev, "native mode from preferred\n"); 547 return drm_mode_duplicate(dev, mode); 548 } 549 550 /* Otherwise, take the resolution with the largest width, then 551 * height, then vertical refresh 552 */ 553 if (mode->hdisplay < high_w) 554 continue; 555 556 if (mode->hdisplay == high_w && mode->vdisplay < high_h) 557 continue; 558 559 if (mode->hdisplay == high_w && mode->vdisplay == high_h && 560 mode->vrefresh < high_v) 561 continue; 562 563 high_w = mode->hdisplay; 564 high_h = mode->vdisplay; 565 high_v = mode->vrefresh; 566 largest = mode; 567 } 568 569 NV_DEBUG_KMS(dev, "native mode from largest: %dx%d@%d\n", 570 high_w, high_h, high_v); 571 return largest ? drm_mode_duplicate(dev, largest) : NULL; 572 } 573 574 struct moderec { 575 int hdisplay; 576 int vdisplay; 577 }; 578 579 static struct moderec scaler_modes[] = { 580 { 1920, 1200 }, 581 { 1920, 1080 }, 582 { 1680, 1050 }, 583 { 1600, 1200 }, 584 { 1400, 1050 }, 585 { 1280, 1024 }, 586 { 1280, 960 }, 587 { 1152, 864 }, 588 { 1024, 768 }, 589 { 800, 600 }, 590 { 720, 400 }, 591 { 640, 480 }, 592 { 640, 400 }, 593 { 640, 350 }, 594 {} 595 }; 596 597 static int 598 nouveau_connector_scaler_modes_add(struct drm_connector *connector) 599 { 600 struct nouveau_connector *nv_connector = nouveau_connector(connector); 601 struct drm_display_mode *native = nv_connector->native_mode, *m; 602 struct drm_device *dev = connector->dev; 603 struct moderec *mode = &scaler_modes[0]; 604 int modes = 0; 605 606 if (!native) 607 return 0; 608 609 while (mode->hdisplay) { 610 if (mode->hdisplay <= native->hdisplay && 611 mode->vdisplay <= native->vdisplay) { 612 m = drm_cvt_mode(dev, mode->hdisplay, mode->vdisplay, 613 drm_mode_vrefresh(native), false, 614 false, false); 615 if (!m) 616 continue; 617 618 m->type |= DRM_MODE_TYPE_DRIVER; 619 620 drm_mode_probed_add(connector, m); 621 modes++; 622 } 623 624 mode++; 625 } 626 627 return modes; 628 } 629 630 static void 631 nouveau_connector_detect_depth(struct drm_connector *connector) 632 { 633 struct drm_nouveau_private *dev_priv = connector->dev->dev_private; 634 struct nouveau_connector *nv_connector = nouveau_connector(connector); 635 struct nouveau_encoder *nv_encoder = nv_connector->detected_encoder; 636 struct nvbios *bios = &dev_priv->vbios; 637 struct drm_display_mode *mode = nv_connector->native_mode; 638 bool duallink; 639 640 /* if the edid is feeling nice enough to provide this info, use it */ 641 if (nv_connector->edid && connector->display_info.bpc) 642 return; 643 644 /* if not, we're out of options unless we're LVDS, default to 6bpc */ 645 connector->display_info.bpc = 6; 646 if (nv_encoder->dcb->type != OUTPUT_LVDS) 647 return; 648 649 /* LVDS: panel straps */ 650 if (bios->fp_no_ddc) { 651 if (bios->fp.if_is_24bit) 652 connector->display_info.bpc = 8; 653 return; 654 } 655 656 /* LVDS: DDC panel, need to first determine the number of links to 657 * know which if_is_24bit flag to check... 658 */ 659 if (nv_connector->edid && 660 nv_connector->type == DCB_CONNECTOR_LVDS_SPWG) 661 duallink = ((u8 *)nv_connector->edid)[121] == 2; 662 else 663 duallink = mode->clock >= bios->fp.duallink_transition_clk; 664 665 if ((!duallink && (bios->fp.strapless_is_24bit & 1)) || 666 ( duallink && (bios->fp.strapless_is_24bit & 2))) 667 connector->display_info.bpc = 8; 668 } 669 670 static int 671 nouveau_connector_get_modes(struct drm_connector *connector) 672 { 673 struct drm_device *dev = connector->dev; 674 struct drm_nouveau_private *dev_priv = dev->dev_private; 675 struct nouveau_connector *nv_connector = nouveau_connector(connector); 676 struct nouveau_encoder *nv_encoder = nv_connector->detected_encoder; 677 struct drm_encoder *encoder = to_drm_encoder(nv_encoder); 678 int ret = 0; 679 680 /* destroy the native mode, the attached monitor could have changed. 681 */ 682 if (nv_connector->native_mode) { 683 drm_mode_destroy(dev, nv_connector->native_mode); 684 nv_connector->native_mode = NULL; 685 } 686 687 if (nv_connector->edid) 688 ret = drm_add_edid_modes(connector, nv_connector->edid); 689 else 690 if (nv_encoder->dcb->type == OUTPUT_LVDS && 691 (nv_encoder->dcb->lvdsconf.use_straps_for_mode || 692 dev_priv->vbios.fp_no_ddc) && nouveau_bios_fp_mode(dev, NULL)) { 693 struct drm_display_mode mode; 694 695 nouveau_bios_fp_mode(dev, &mode); 696 nv_connector->native_mode = drm_mode_duplicate(dev, &mode); 697 } 698 699 /* Determine display colour depth for everything except LVDS now, 700 * DP requires this before mode_valid() is called. 701 */ 702 if (connector->connector_type != DRM_MODE_CONNECTOR_LVDS) 703 nouveau_connector_detect_depth(connector); 704 705 /* Find the native mode if this is a digital panel, if we didn't 706 * find any modes through DDC previously add the native mode to 707 * the list of modes. 708 */ 709 if (!nv_connector->native_mode) 710 nv_connector->native_mode = 711 nouveau_connector_native_mode(connector); 712 if (ret == 0 && nv_connector->native_mode) { 713 struct drm_display_mode *mode; 714 715 mode = drm_mode_duplicate(dev, nv_connector->native_mode); 716 drm_mode_probed_add(connector, mode); 717 ret = 1; 718 } 719 720 /* Determine LVDS colour depth, must happen after determining 721 * "native" mode as some VBIOS tables require us to use the 722 * pixel clock as part of the lookup... 723 */ 724 if (connector->connector_type == DRM_MODE_CONNECTOR_LVDS) 725 nouveau_connector_detect_depth(connector); 726 727 if (nv_encoder->dcb->type == OUTPUT_TV) 728 ret = get_slave_funcs(encoder)->get_modes(encoder, connector); 729 730 if (nv_connector->type == DCB_CONNECTOR_LVDS || 731 nv_connector->type == DCB_CONNECTOR_LVDS_SPWG || 732 nv_connector->type == DCB_CONNECTOR_eDP) 733 ret += nouveau_connector_scaler_modes_add(connector); 734 735 return ret; 736 } 737 738 static unsigned 739 get_tmds_link_bandwidth(struct drm_connector *connector) 740 { 741 struct nouveau_connector *nv_connector = nouveau_connector(connector); 742 struct drm_nouveau_private *dev_priv = connector->dev->dev_private; 743 struct dcb_entry *dcb = nv_connector->detected_encoder->dcb; 744 745 if (dcb->location != DCB_LOC_ON_CHIP || 746 dev_priv->chipset >= 0x46) 747 return 165000; 748 else if (dev_priv->chipset >= 0x40) 749 return 155000; 750 else if (dev_priv->chipset >= 0x18) 751 return 135000; 752 else 753 return 112000; 754 } 755 756 static int 757 nouveau_connector_mode_valid(struct drm_connector *connector, 758 struct drm_display_mode *mode) 759 { 760 struct nouveau_connector *nv_connector = nouveau_connector(connector); 761 struct nouveau_encoder *nv_encoder = nv_connector->detected_encoder; 762 struct drm_encoder *encoder = to_drm_encoder(nv_encoder); 763 unsigned min_clock = 25000, max_clock = min_clock; 764 unsigned clock = mode->clock; 765 766 switch (nv_encoder->dcb->type) { 767 case OUTPUT_LVDS: 768 if (nv_connector->native_mode && 769 (mode->hdisplay > nv_connector->native_mode->hdisplay || 770 mode->vdisplay > nv_connector->native_mode->vdisplay)) 771 return MODE_PANEL; 772 773 min_clock = 0; 774 max_clock = 400000; 775 break; 776 case OUTPUT_TMDS: 777 max_clock = get_tmds_link_bandwidth(connector); 778 if (nouveau_duallink && nv_encoder->dcb->duallink_possible) 779 max_clock *= 2; 780 break; 781 case OUTPUT_ANALOG: 782 max_clock = nv_encoder->dcb->crtconf.maxfreq; 783 if (!max_clock) 784 max_clock = 350000; 785 break; 786 case OUTPUT_TV: 787 return get_slave_funcs(encoder)->mode_valid(encoder, mode); 788 case OUTPUT_DP: 789 max_clock = nv_encoder->dp.link_nr; 790 max_clock *= nv_encoder->dp.link_bw; 791 clock = clock * (connector->display_info.bpc * 3) / 10; 792 break; 793 default: 794 BUG_ON(1); 795 return MODE_BAD; 796 } 797 798 if (clock < min_clock) 799 return MODE_CLOCK_LOW; 800 801 if (clock > max_clock) 802 return MODE_CLOCK_HIGH; 803 804 return MODE_OK; 805 } 806 807 static struct drm_encoder * 808 nouveau_connector_best_encoder(struct drm_connector *connector) 809 { 810 struct nouveau_connector *nv_connector = nouveau_connector(connector); 811 812 if (nv_connector->detected_encoder) 813 return to_drm_encoder(nv_connector->detected_encoder); 814 815 return NULL; 816 } 817 818 static const struct drm_connector_helper_funcs 819 nouveau_connector_helper_funcs = { 820 .get_modes = nouveau_connector_get_modes, 821 .mode_valid = nouveau_connector_mode_valid, 822 .best_encoder = nouveau_connector_best_encoder, 823 }; 824 825 static const struct drm_connector_funcs 826 nouveau_connector_funcs = { 827 .dpms = drm_helper_connector_dpms, 828 .save = NULL, 829 .restore = NULL, 830 .detect = nouveau_connector_detect, 831 .destroy = nouveau_connector_destroy, 832 .fill_modes = drm_helper_probe_single_connector_modes, 833 .set_property = nouveau_connector_set_property, 834 .force = nouveau_connector_force 835 }; 836 837 static const struct drm_connector_funcs 838 nouveau_connector_funcs_lvds = { 839 .dpms = drm_helper_connector_dpms, 840 .save = NULL, 841 .restore = NULL, 842 .detect = nouveau_connector_detect_lvds, 843 .destroy = nouveau_connector_destroy, 844 .fill_modes = drm_helper_probe_single_connector_modes, 845 .set_property = nouveau_connector_set_property, 846 .force = nouveau_connector_force 847 }; 848 849 static int 850 drm_conntype_from_dcb(enum dcb_connector_type dcb) 851 { 852 switch (dcb) { 853 case DCB_CONNECTOR_VGA : return DRM_MODE_CONNECTOR_VGA; 854 case DCB_CONNECTOR_TV_0 : 855 case DCB_CONNECTOR_TV_1 : 856 case DCB_CONNECTOR_TV_3 : return DRM_MODE_CONNECTOR_TV; 857 case DCB_CONNECTOR_DVI_I : return DRM_MODE_CONNECTOR_DVII; 858 case DCB_CONNECTOR_DVI_D : return DRM_MODE_CONNECTOR_DVID; 859 case DCB_CONNECTOR_LVDS : 860 case DCB_CONNECTOR_LVDS_SPWG: return DRM_MODE_CONNECTOR_LVDS; 861 case DCB_CONNECTOR_DP : return DRM_MODE_CONNECTOR_DisplayPort; 862 case DCB_CONNECTOR_eDP : return DRM_MODE_CONNECTOR_eDP; 863 case DCB_CONNECTOR_HDMI_0 : 864 case DCB_CONNECTOR_HDMI_1 : return DRM_MODE_CONNECTOR_HDMIA; 865 default: 866 break; 867 } 868 869 return DRM_MODE_CONNECTOR_Unknown; 870 } 871 872 struct drm_connector * 873 nouveau_connector_create(struct drm_device *dev, int index) 874 { 875 const struct drm_connector_funcs *funcs = &nouveau_connector_funcs; 876 struct drm_nouveau_private *dev_priv = dev->dev_private; 877 struct nouveau_display_engine *disp = &dev_priv->engine.display; 878 struct nouveau_connector *nv_connector = NULL; 879 struct drm_connector *connector; 880 int type, ret = 0; 881 bool dummy; 882 883 NV_DEBUG_KMS(dev, "\n"); 884 885 list_for_each_entry(connector, &dev->mode_config.connector_list, head) { 886 nv_connector = nouveau_connector(connector); 887 if (nv_connector->index == index) 888 return connector; 889 } 890 891 nv_connector = kzalloc(sizeof(*nv_connector), GFP_KERNEL); 892 if (!nv_connector) 893 return ERR_PTR(-ENOMEM); 894 895 connector = &nv_connector->base; 896 nv_connector->index = index; 897 898 /* attempt to parse vbios connector type and hotplug gpio */ 899 nv_connector->dcb = dcb_conn(dev, index); 900 if (nv_connector->dcb) { 901 static const u8 hpd[16] = { 902 0xff, 0x07, 0x08, 0xff, 0xff, 0x51, 0x52, 0xff, 903 0xff, 0xff, 0xff, 0xff, 0xff, 0x5e, 0x5f, 0x60, 904 }; 905 906 u32 entry = ROM16(nv_connector->dcb[0]); 907 if (dcb_conntab(dev)[3] >= 4) 908 entry |= (u32)ROM16(nv_connector->dcb[2]) << 16; 909 910 nv_connector->hpd = ffs((entry & 0x07033000) >> 12); 911 nv_connector->hpd = hpd[nv_connector->hpd]; 912 913 nv_connector->type = nv_connector->dcb[0]; 914 if (drm_conntype_from_dcb(nv_connector->type) == 915 DRM_MODE_CONNECTOR_Unknown) { 916 NV_WARN(dev, "unknown connector type %02x\n", 917 nv_connector->type); 918 nv_connector->type = DCB_CONNECTOR_NONE; 919 } 920 921 /* Gigabyte NX85T */ 922 if (nv_match_device(dev, 0x0421, 0x1458, 0x344c)) { 923 if (nv_connector->type == DCB_CONNECTOR_HDMI_1) 924 nv_connector->type = DCB_CONNECTOR_DVI_I; 925 } 926 927 /* Gigabyte GV-NX86T512H */ 928 if (nv_match_device(dev, 0x0402, 0x1458, 0x3455)) { 929 if (nv_connector->type == DCB_CONNECTOR_HDMI_1) 930 nv_connector->type = DCB_CONNECTOR_DVI_I; 931 } 932 } else { 933 nv_connector->type = DCB_CONNECTOR_NONE; 934 nv_connector->hpd = DCB_GPIO_UNUSED; 935 } 936 937 /* no vbios data, or an unknown dcb connector type - attempt to 938 * figure out something suitable ourselves 939 */ 940 if (nv_connector->type == DCB_CONNECTOR_NONE) { 941 struct drm_nouveau_private *dev_priv = dev->dev_private; 942 struct dcb_table *dcbt = &dev_priv->vbios.dcb; 943 u32 encoders = 0; 944 int i; 945 946 for (i = 0; i < dcbt->entries; i++) { 947 if (dcbt->entry[i].connector == nv_connector->index) 948 encoders |= (1 << dcbt->entry[i].type); 949 } 950 951 if (encoders & (1 << OUTPUT_DP)) { 952 if (encoders & (1 << OUTPUT_TMDS)) 953 nv_connector->type = DCB_CONNECTOR_DP; 954 else 955 nv_connector->type = DCB_CONNECTOR_eDP; 956 } else 957 if (encoders & (1 << OUTPUT_TMDS)) { 958 if (encoders & (1 << OUTPUT_ANALOG)) 959 nv_connector->type = DCB_CONNECTOR_DVI_I; 960 else 961 nv_connector->type = DCB_CONNECTOR_DVI_D; 962 } else 963 if (encoders & (1 << OUTPUT_ANALOG)) { 964 nv_connector->type = DCB_CONNECTOR_VGA; 965 } else 966 if (encoders & (1 << OUTPUT_LVDS)) { 967 nv_connector->type = DCB_CONNECTOR_LVDS; 968 } else 969 if (encoders & (1 << OUTPUT_TV)) { 970 nv_connector->type = DCB_CONNECTOR_TV_0; 971 } 972 } 973 974 type = drm_conntype_from_dcb(nv_connector->type); 975 if (type == DRM_MODE_CONNECTOR_LVDS) { 976 ret = nouveau_bios_parse_lvds_table(dev, 0, &dummy, &dummy); 977 if (ret) { 978 NV_ERROR(dev, "Error parsing LVDS table, disabling\n"); 979 kfree(nv_connector); 980 return ERR_PTR(ret); 981 } 982 983 funcs = &nouveau_connector_funcs_lvds; 984 } else { 985 funcs = &nouveau_connector_funcs; 986 } 987 988 /* defaults, will get overridden in detect() */ 989 connector->interlace_allowed = false; 990 connector->doublescan_allowed = false; 991 992 drm_connector_init(dev, connector, funcs, type); 993 drm_connector_helper_add(connector, &nouveau_connector_helper_funcs); 994 995 /* Init DVI-I specific properties */ 996 if (nv_connector->type == DCB_CONNECTOR_DVI_I) 997 drm_connector_attach_property(connector, dev->mode_config.dvi_i_subconnector_property, 0); 998 999 /* Add overscan compensation options to digital outputs */ 1000 if (disp->underscan_property && 1001 (nv_connector->type == DCB_CONNECTOR_DVI_D || 1002 nv_connector->type == DCB_CONNECTOR_DVI_I || 1003 nv_connector->type == DCB_CONNECTOR_HDMI_0 || 1004 nv_connector->type == DCB_CONNECTOR_HDMI_1 || 1005 nv_connector->type == DCB_CONNECTOR_DP)) { 1006 drm_connector_attach_property(connector, 1007 disp->underscan_property, 1008 UNDERSCAN_OFF); 1009 drm_connector_attach_property(connector, 1010 disp->underscan_hborder_property, 1011 0); 1012 drm_connector_attach_property(connector, 1013 disp->underscan_vborder_property, 1014 0); 1015 } 1016 1017 switch (nv_connector->type) { 1018 case DCB_CONNECTOR_VGA: 1019 if (dev_priv->card_type >= NV_50) { 1020 drm_connector_attach_property(connector, 1021 dev->mode_config.scaling_mode_property, 1022 nv_connector->scaling_mode); 1023 } 1024 /* fall-through */ 1025 case DCB_CONNECTOR_TV_0: 1026 case DCB_CONNECTOR_TV_1: 1027 case DCB_CONNECTOR_TV_3: 1028 nv_connector->scaling_mode = DRM_MODE_SCALE_NONE; 1029 break; 1030 default: 1031 nv_connector->scaling_mode = DRM_MODE_SCALE_FULLSCREEN; 1032 1033 drm_connector_attach_property(connector, 1034 dev->mode_config.scaling_mode_property, 1035 nv_connector->scaling_mode); 1036 if (disp->dithering_mode) { 1037 nv_connector->dithering_mode = DITHERING_MODE_AUTO; 1038 drm_connector_attach_property(connector, 1039 disp->dithering_mode, 1040 nv_connector->dithering_mode); 1041 } 1042 if (disp->dithering_depth) { 1043 nv_connector->dithering_depth = DITHERING_DEPTH_AUTO; 1044 drm_connector_attach_property(connector, 1045 disp->dithering_depth, 1046 nv_connector->dithering_depth); 1047 } 1048 break; 1049 } 1050 1051 connector->polled = DRM_CONNECTOR_POLL_CONNECT; 1052 if (nv_connector->hpd != DCB_GPIO_UNUSED) { 1053 ret = nouveau_gpio_isr_add(dev, 0, nv_connector->hpd, 0xff, 1054 nouveau_connector_hotplug, 1055 connector); 1056 if (ret == 0) 1057 connector->polled = DRM_CONNECTOR_POLL_HPD; 1058 } 1059 1060 drm_sysfs_connector_add(connector); 1061 return connector; 1062 } 1063 1064 static void 1065 nouveau_connector_hotplug(void *data, int plugged) 1066 { 1067 struct drm_connector *connector = data; 1068 struct drm_device *dev = connector->dev; 1069 1070 NV_DEBUG(dev, "%splugged %s\n", plugged ? "" : "un", 1071 drm_get_connector_name(connector)); 1072 1073 if (plugged) 1074 drm_helper_connector_dpms(connector, DRM_MODE_DPMS_ON); 1075 else 1076 drm_helper_connector_dpms(connector, DRM_MODE_DPMS_OFF); 1077 1078 drm_helper_hpd_irq_event(dev); 1079 } 1080