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 <linux/pm_runtime.h> 30 #include <linux/vga_switcheroo.h> 31 32 #include <drm/drmP.h> 33 #include <drm/drm_atomic_helper.h> 34 #include <drm/drm_edid.h> 35 #include <drm/drm_crtc_helper.h> 36 37 #include "nouveau_reg.h" 38 #include "nouveau_drv.h" 39 #include "dispnv04/hw.h" 40 #include "nouveau_acpi.h" 41 42 #include "nouveau_display.h" 43 #include "nouveau_connector.h" 44 #include "nouveau_encoder.h" 45 #include "nouveau_crtc.h" 46 47 #include <nvif/class.h> 48 #include <nvif/cl0046.h> 49 #include <nvif/event.h> 50 51 struct drm_display_mode * 52 nouveau_conn_native_mode(struct drm_connector *connector) 53 { 54 const struct drm_connector_helper_funcs *helper = connector->helper_private; 55 struct nouveau_drm *drm = nouveau_drm(connector->dev); 56 struct drm_device *dev = connector->dev; 57 struct drm_display_mode *mode, *largest = NULL; 58 int high_w = 0, high_h = 0, high_v = 0; 59 60 list_for_each_entry(mode, &connector->probed_modes, head) { 61 mode->vrefresh = drm_mode_vrefresh(mode); 62 if (helper->mode_valid(connector, mode) != MODE_OK || 63 (mode->flags & DRM_MODE_FLAG_INTERLACE)) 64 continue; 65 66 /* Use preferred mode if there is one.. */ 67 if (mode->type & DRM_MODE_TYPE_PREFERRED) { 68 NV_DEBUG(drm, "native mode from preferred\n"); 69 return drm_mode_duplicate(dev, mode); 70 } 71 72 /* Otherwise, take the resolution with the largest width, then 73 * height, then vertical refresh 74 */ 75 if (mode->hdisplay < high_w) 76 continue; 77 78 if (mode->hdisplay == high_w && mode->vdisplay < high_h) 79 continue; 80 81 if (mode->hdisplay == high_w && mode->vdisplay == high_h && 82 mode->vrefresh < high_v) 83 continue; 84 85 high_w = mode->hdisplay; 86 high_h = mode->vdisplay; 87 high_v = mode->vrefresh; 88 largest = mode; 89 } 90 91 NV_DEBUG(drm, "native mode from largest: %dx%d@%d\n", 92 high_w, high_h, high_v); 93 return largest ? drm_mode_duplicate(dev, largest) : NULL; 94 } 95 96 int 97 nouveau_conn_atomic_get_property(struct drm_connector *connector, 98 const struct drm_connector_state *state, 99 struct drm_property *property, u64 *val) 100 { 101 struct nouveau_conn_atom *asyc = nouveau_conn_atom(state); 102 struct nouveau_display *disp = nouveau_display(connector->dev); 103 struct drm_device *dev = connector->dev; 104 105 if (property == dev->mode_config.scaling_mode_property) 106 *val = asyc->scaler.mode; 107 else if (property == disp->underscan_property) 108 *val = asyc->scaler.underscan.mode; 109 else if (property == disp->underscan_hborder_property) 110 *val = asyc->scaler.underscan.hborder; 111 else if (property == disp->underscan_vborder_property) 112 *val = asyc->scaler.underscan.vborder; 113 else if (property == disp->dithering_mode) 114 *val = asyc->dither.mode; 115 else if (property == disp->dithering_depth) 116 *val = asyc->dither.depth; 117 else if (property == disp->vibrant_hue_property) 118 *val = asyc->procamp.vibrant_hue; 119 else if (property == disp->color_vibrance_property) 120 *val = asyc->procamp.color_vibrance; 121 else 122 return -EINVAL; 123 124 return 0; 125 } 126 127 int 128 nouveau_conn_atomic_set_property(struct drm_connector *connector, 129 struct drm_connector_state *state, 130 struct drm_property *property, u64 val) 131 { 132 struct drm_device *dev = connector->dev; 133 struct nouveau_conn_atom *asyc = nouveau_conn_atom(state); 134 struct nouveau_display *disp = nouveau_display(dev); 135 136 if (property == dev->mode_config.scaling_mode_property) { 137 switch (val) { 138 case DRM_MODE_SCALE_NONE: 139 /* We allow 'None' for EDID modes, even on a fixed 140 * panel (some exist with support for lower refresh 141 * rates, which people might want to use for power- 142 * saving purposes). 143 * 144 * Non-EDID modes will force the use of GPU scaling 145 * to the native mode regardless of this setting. 146 */ 147 switch (connector->connector_type) { 148 case DRM_MODE_CONNECTOR_LVDS: 149 case DRM_MODE_CONNECTOR_eDP: 150 /* ... except prior to G80, where the code 151 * doesn't support such things. 152 */ 153 if (disp->disp.oclass < NV50_DISP) 154 return -EINVAL; 155 break; 156 default: 157 break; 158 } 159 case DRM_MODE_SCALE_FULLSCREEN: 160 case DRM_MODE_SCALE_CENTER: 161 case DRM_MODE_SCALE_ASPECT: 162 break; 163 default: 164 return -EINVAL; 165 } 166 167 if (asyc->scaler.mode != val) { 168 asyc->scaler.mode = val; 169 asyc->set.scaler = true; 170 } 171 } else 172 if (property == disp->underscan_property) { 173 if (asyc->scaler.underscan.mode != val) { 174 asyc->scaler.underscan.mode = val; 175 asyc->set.scaler = true; 176 } 177 } else 178 if (property == disp->underscan_hborder_property) { 179 if (asyc->scaler.underscan.hborder != val) { 180 asyc->scaler.underscan.hborder = val; 181 asyc->set.scaler = true; 182 } 183 } else 184 if (property == disp->underscan_vborder_property) { 185 if (asyc->scaler.underscan.vborder != val) { 186 asyc->scaler.underscan.vborder = val; 187 asyc->set.scaler = true; 188 } 189 } else 190 if (property == disp->dithering_mode) { 191 if (asyc->dither.mode != val) { 192 asyc->dither.mode = val; 193 asyc->set.dither = true; 194 } 195 } else 196 if (property == disp->dithering_depth) { 197 if (asyc->dither.mode != val) { 198 asyc->dither.depth = val; 199 asyc->set.dither = true; 200 } 201 } else 202 if (property == disp->vibrant_hue_property) { 203 if (asyc->procamp.vibrant_hue != val) { 204 asyc->procamp.vibrant_hue = val; 205 asyc->set.procamp = true; 206 } 207 } else 208 if (property == disp->color_vibrance_property) { 209 if (asyc->procamp.color_vibrance != val) { 210 asyc->procamp.color_vibrance = val; 211 asyc->set.procamp = true; 212 } 213 } else { 214 return -EINVAL; 215 } 216 217 return 0; 218 } 219 220 void 221 nouveau_conn_atomic_destroy_state(struct drm_connector *connector, 222 struct drm_connector_state *state) 223 { 224 struct nouveau_conn_atom *asyc = nouveau_conn_atom(state); 225 __drm_atomic_helper_connector_destroy_state(&asyc->state); 226 kfree(asyc); 227 } 228 229 struct drm_connector_state * 230 nouveau_conn_atomic_duplicate_state(struct drm_connector *connector) 231 { 232 struct nouveau_conn_atom *armc = nouveau_conn_atom(connector->state); 233 struct nouveau_conn_atom *asyc; 234 if (!(asyc = kmalloc(sizeof(*asyc), GFP_KERNEL))) 235 return NULL; 236 __drm_atomic_helper_connector_duplicate_state(connector, &asyc->state); 237 asyc->dither = armc->dither; 238 asyc->scaler = armc->scaler; 239 asyc->procamp = armc->procamp; 240 asyc->set.mask = 0; 241 return &asyc->state; 242 } 243 244 void 245 nouveau_conn_reset(struct drm_connector *connector) 246 { 247 struct nouveau_conn_atom *asyc; 248 249 if (WARN_ON(!(asyc = kzalloc(sizeof(*asyc), GFP_KERNEL)))) 250 return; 251 252 if (connector->state) 253 __drm_atomic_helper_connector_destroy_state(connector->state); 254 __drm_atomic_helper_connector_reset(connector, &asyc->state); 255 asyc->dither.mode = DITHERING_MODE_AUTO; 256 asyc->dither.depth = DITHERING_DEPTH_AUTO; 257 asyc->scaler.mode = DRM_MODE_SCALE_NONE; 258 asyc->scaler.underscan.mode = UNDERSCAN_OFF; 259 asyc->procamp.color_vibrance = 150; 260 asyc->procamp.vibrant_hue = 90; 261 262 if (nouveau_display(connector->dev)->disp.oclass < NV50_DISP) { 263 switch (connector->connector_type) { 264 case DRM_MODE_CONNECTOR_LVDS: 265 /* See note in nouveau_conn_atomic_set_property(). */ 266 asyc->scaler.mode = DRM_MODE_SCALE_FULLSCREEN; 267 break; 268 default: 269 break; 270 } 271 } 272 } 273 274 void 275 nouveau_conn_attach_properties(struct drm_connector *connector) 276 { 277 struct drm_device *dev = connector->dev; 278 struct nouveau_conn_atom *armc = nouveau_conn_atom(connector->state); 279 struct nouveau_display *disp = nouveau_display(dev); 280 281 /* Init DVI-I specific properties. */ 282 if (connector->connector_type == DRM_MODE_CONNECTOR_DVII) 283 drm_object_attach_property(&connector->base, dev->mode_config. 284 dvi_i_subconnector_property, 0); 285 286 /* Add overscan compensation options to digital outputs. */ 287 if (disp->underscan_property && 288 (connector->connector_type == DRM_MODE_CONNECTOR_DVID || 289 connector->connector_type == DRM_MODE_CONNECTOR_DVII || 290 connector->connector_type == DRM_MODE_CONNECTOR_HDMIA || 291 connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort)) { 292 drm_object_attach_property(&connector->base, 293 disp->underscan_property, 294 UNDERSCAN_OFF); 295 drm_object_attach_property(&connector->base, 296 disp->underscan_hborder_property, 0); 297 drm_object_attach_property(&connector->base, 298 disp->underscan_vborder_property, 0); 299 } 300 301 /* Add hue and saturation options. */ 302 if (disp->vibrant_hue_property) 303 drm_object_attach_property(&connector->base, 304 disp->vibrant_hue_property, 305 armc->procamp.vibrant_hue); 306 if (disp->color_vibrance_property) 307 drm_object_attach_property(&connector->base, 308 disp->color_vibrance_property, 309 armc->procamp.color_vibrance); 310 311 /* Scaling mode property. */ 312 switch (connector->connector_type) { 313 case DRM_MODE_CONNECTOR_TV: 314 break; 315 case DRM_MODE_CONNECTOR_VGA: 316 if (disp->disp.oclass < NV50_DISP) 317 break; /* Can only scale on DFPs. */ 318 /* Fall-through. */ 319 default: 320 drm_object_attach_property(&connector->base, dev->mode_config. 321 scaling_mode_property, 322 armc->scaler.mode); 323 break; 324 } 325 326 /* Dithering properties. */ 327 switch (connector->connector_type) { 328 case DRM_MODE_CONNECTOR_TV: 329 case DRM_MODE_CONNECTOR_VGA: 330 break; 331 default: 332 if (disp->dithering_mode) { 333 drm_object_attach_property(&connector->base, 334 disp->dithering_mode, 335 armc->dither.mode); 336 } 337 if (disp->dithering_depth) { 338 drm_object_attach_property(&connector->base, 339 disp->dithering_depth, 340 armc->dither.depth); 341 } 342 break; 343 } 344 } 345 346 MODULE_PARM_DESC(tv_disable, "Disable TV-out detection"); 347 int nouveau_tv_disable = 0; 348 module_param_named(tv_disable, nouveau_tv_disable, int, 0400); 349 350 MODULE_PARM_DESC(ignorelid, "Ignore ACPI lid status"); 351 int nouveau_ignorelid = 0; 352 module_param_named(ignorelid, nouveau_ignorelid, int, 0400); 353 354 MODULE_PARM_DESC(duallink, "Allow dual-link TMDS (default: enabled)"); 355 int nouveau_duallink = 1; 356 module_param_named(duallink, nouveau_duallink, int, 0400); 357 358 MODULE_PARM_DESC(hdmimhz, "Force a maximum HDMI pixel clock (in MHz)"); 359 int nouveau_hdmimhz = 0; 360 module_param_named(hdmimhz, nouveau_hdmimhz, int, 0400); 361 362 struct nouveau_encoder * 363 find_encoder(struct drm_connector *connector, int type) 364 { 365 struct drm_device *dev = connector->dev; 366 struct nouveau_encoder *nv_encoder; 367 struct drm_encoder *enc; 368 int i, id; 369 370 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) { 371 id = connector->encoder_ids[i]; 372 if (!id) 373 break; 374 375 enc = drm_encoder_find(dev, id); 376 if (!enc) 377 continue; 378 nv_encoder = nouveau_encoder(enc); 379 380 if (type == DCB_OUTPUT_ANY || 381 (nv_encoder->dcb && nv_encoder->dcb->type == type)) 382 return nv_encoder; 383 } 384 385 return NULL; 386 } 387 388 struct nouveau_connector * 389 nouveau_encoder_connector_get(struct nouveau_encoder *encoder) 390 { 391 struct drm_device *dev = to_drm_encoder(encoder)->dev; 392 struct drm_connector *drm_connector; 393 394 list_for_each_entry(drm_connector, &dev->mode_config.connector_list, head) { 395 if (drm_connector->encoder == to_drm_encoder(encoder)) 396 return nouveau_connector(drm_connector); 397 } 398 399 return NULL; 400 } 401 402 static void 403 nouveau_connector_destroy(struct drm_connector *connector) 404 { 405 struct nouveau_connector *nv_connector = nouveau_connector(connector); 406 nvif_notify_fini(&nv_connector->hpd); 407 kfree(nv_connector->edid); 408 drm_connector_unregister(connector); 409 drm_connector_cleanup(connector); 410 if (nv_connector->aux.transfer) 411 drm_dp_aux_unregister(&nv_connector->aux); 412 kfree(connector); 413 } 414 415 static struct nouveau_encoder * 416 nouveau_connector_ddc_detect(struct drm_connector *connector) 417 { 418 struct drm_device *dev = connector->dev; 419 struct nouveau_connector *nv_connector = nouveau_connector(connector); 420 struct nouveau_drm *drm = nouveau_drm(dev); 421 struct nvkm_gpio *gpio = nvxx_gpio(&drm->device); 422 struct nouveau_encoder *nv_encoder; 423 struct drm_encoder *encoder; 424 int i, panel = -ENODEV; 425 426 /* eDP panels need powering on by us (if the VBIOS doesn't default it 427 * to on) before doing any AUX channel transactions. LVDS panel power 428 * is handled by the SOR itself, and not required for LVDS DDC. 429 */ 430 if (nv_connector->type == DCB_CONNECTOR_eDP) { 431 panel = nvkm_gpio_get(gpio, 0, DCB_GPIO_PANEL_POWER, 0xff); 432 if (panel == 0) { 433 nvkm_gpio_set(gpio, 0, DCB_GPIO_PANEL_POWER, 0xff, 1); 434 msleep(300); 435 } 436 } 437 438 for (i = 0; nv_encoder = NULL, i < DRM_CONNECTOR_MAX_ENCODER; i++) { 439 int id = connector->encoder_ids[i]; 440 if (id == 0) 441 break; 442 443 encoder = drm_encoder_find(dev, id); 444 if (!encoder) 445 continue; 446 nv_encoder = nouveau_encoder(encoder); 447 448 if (nv_encoder->dcb->type == DCB_OUTPUT_DP) { 449 int ret = nouveau_dp_detect(nv_encoder); 450 if (ret == NOUVEAU_DP_MST) 451 return NULL; 452 if (ret == NOUVEAU_DP_SST) 453 break; 454 } else 455 if ((vga_switcheroo_handler_flags() & 456 VGA_SWITCHEROO_CAN_SWITCH_DDC) && 457 nv_encoder->dcb->type == DCB_OUTPUT_LVDS && 458 nv_encoder->i2c) { 459 int ret; 460 vga_switcheroo_lock_ddc(dev->pdev); 461 ret = nvkm_probe_i2c(nv_encoder->i2c, 0x50); 462 vga_switcheroo_unlock_ddc(dev->pdev); 463 if (ret) 464 break; 465 } else 466 if (nv_encoder->i2c) { 467 if (nvkm_probe_i2c(nv_encoder->i2c, 0x50)) 468 break; 469 } 470 } 471 472 /* eDP panel not detected, restore panel power GPIO to previous 473 * state to avoid confusing the SOR for other output types. 474 */ 475 if (!nv_encoder && panel == 0) 476 nvkm_gpio_set(gpio, 0, DCB_GPIO_PANEL_POWER, 0xff, panel); 477 478 return nv_encoder; 479 } 480 481 static struct nouveau_encoder * 482 nouveau_connector_of_detect(struct drm_connector *connector) 483 { 484 #ifdef __powerpc__ 485 struct drm_device *dev = connector->dev; 486 struct nouveau_connector *nv_connector = nouveau_connector(connector); 487 struct nouveau_encoder *nv_encoder; 488 struct device_node *cn, *dn = pci_device_to_OF_node(dev->pdev); 489 490 if (!dn || 491 !((nv_encoder = find_encoder(connector, DCB_OUTPUT_TMDS)) || 492 (nv_encoder = find_encoder(connector, DCB_OUTPUT_ANALOG)))) 493 return NULL; 494 495 for_each_child_of_node(dn, cn) { 496 const char *name = of_get_property(cn, "name", NULL); 497 const void *edid = of_get_property(cn, "EDID", NULL); 498 int idx = name ? name[strlen(name) - 1] - 'A' : 0; 499 500 if (nv_encoder->dcb->i2c_index == idx && edid) { 501 nv_connector->edid = 502 kmemdup(edid, EDID_LENGTH, GFP_KERNEL); 503 of_node_put(cn); 504 return nv_encoder; 505 } 506 } 507 #endif 508 return NULL; 509 } 510 511 static void 512 nouveau_connector_set_encoder(struct drm_connector *connector, 513 struct nouveau_encoder *nv_encoder) 514 { 515 struct nouveau_connector *nv_connector = nouveau_connector(connector); 516 struct nouveau_drm *drm = nouveau_drm(connector->dev); 517 struct drm_device *dev = connector->dev; 518 519 if (nv_connector->detected_encoder == nv_encoder) 520 return; 521 nv_connector->detected_encoder = nv_encoder; 522 523 if (drm->device.info.family >= NV_DEVICE_INFO_V0_TESLA) { 524 connector->interlace_allowed = true; 525 connector->doublescan_allowed = true; 526 } else 527 if (nv_encoder->dcb->type == DCB_OUTPUT_LVDS || 528 nv_encoder->dcb->type == DCB_OUTPUT_TMDS) { 529 connector->doublescan_allowed = false; 530 connector->interlace_allowed = false; 531 } else { 532 connector->doublescan_allowed = true; 533 if (drm->device.info.family == NV_DEVICE_INFO_V0_KELVIN || 534 (drm->device.info.family == NV_DEVICE_INFO_V0_CELSIUS && 535 (dev->pdev->device & 0x0ff0) != 0x0100 && 536 (dev->pdev->device & 0x0ff0) != 0x0150)) 537 /* HW is broken */ 538 connector->interlace_allowed = false; 539 else 540 connector->interlace_allowed = true; 541 } 542 543 if (nv_connector->type == DCB_CONNECTOR_DVI_I) { 544 drm_object_property_set_value(&connector->base, 545 dev->mode_config.dvi_i_subconnector_property, 546 nv_encoder->dcb->type == DCB_OUTPUT_TMDS ? 547 DRM_MODE_SUBCONNECTOR_DVID : 548 DRM_MODE_SUBCONNECTOR_DVIA); 549 } 550 } 551 552 static enum drm_connector_status 553 nouveau_connector_detect(struct drm_connector *connector, bool force) 554 { 555 struct drm_device *dev = connector->dev; 556 struct nouveau_drm *drm = nouveau_drm(dev); 557 struct nouveau_connector *nv_connector = nouveau_connector(connector); 558 struct nouveau_encoder *nv_encoder = NULL; 559 struct nouveau_encoder *nv_partner; 560 struct i2c_adapter *i2c; 561 int type; 562 int ret; 563 enum drm_connector_status conn_status = connector_status_disconnected; 564 565 /* Cleanup the previous EDID block. */ 566 if (nv_connector->edid) { 567 drm_mode_connector_update_edid_property(connector, NULL); 568 kfree(nv_connector->edid); 569 nv_connector->edid = NULL; 570 } 571 572 ret = pm_runtime_get_sync(connector->dev->dev); 573 if (ret < 0 && ret != -EACCES) 574 return conn_status; 575 576 nv_encoder = nouveau_connector_ddc_detect(connector); 577 if (nv_encoder && (i2c = nv_encoder->i2c) != NULL) { 578 if ((vga_switcheroo_handler_flags() & 579 VGA_SWITCHEROO_CAN_SWITCH_DDC) && 580 nv_connector->type == DCB_CONNECTOR_LVDS) 581 nv_connector->edid = drm_get_edid_switcheroo(connector, 582 i2c); 583 else 584 nv_connector->edid = drm_get_edid(connector, i2c); 585 586 drm_mode_connector_update_edid_property(connector, 587 nv_connector->edid); 588 if (!nv_connector->edid) { 589 NV_ERROR(drm, "DDC responded, but no EDID for %s\n", 590 connector->name); 591 goto detect_analog; 592 } 593 594 /* Override encoder type for DVI-I based on whether EDID 595 * says the display is digital or analog, both use the 596 * same i2c channel so the value returned from ddc_detect 597 * isn't necessarily correct. 598 */ 599 nv_partner = NULL; 600 if (nv_encoder->dcb->type == DCB_OUTPUT_TMDS) 601 nv_partner = find_encoder(connector, DCB_OUTPUT_ANALOG); 602 if (nv_encoder->dcb->type == DCB_OUTPUT_ANALOG) 603 nv_partner = find_encoder(connector, DCB_OUTPUT_TMDS); 604 605 if (nv_partner && ((nv_encoder->dcb->type == DCB_OUTPUT_ANALOG && 606 nv_partner->dcb->type == DCB_OUTPUT_TMDS) || 607 (nv_encoder->dcb->type == DCB_OUTPUT_TMDS && 608 nv_partner->dcb->type == DCB_OUTPUT_ANALOG))) { 609 if (nv_connector->edid->input & DRM_EDID_INPUT_DIGITAL) 610 type = DCB_OUTPUT_TMDS; 611 else 612 type = DCB_OUTPUT_ANALOG; 613 614 nv_encoder = find_encoder(connector, type); 615 } 616 617 nouveau_connector_set_encoder(connector, nv_encoder); 618 conn_status = connector_status_connected; 619 goto out; 620 } 621 622 nv_encoder = nouveau_connector_of_detect(connector); 623 if (nv_encoder) { 624 nouveau_connector_set_encoder(connector, nv_encoder); 625 conn_status = connector_status_connected; 626 goto out; 627 } 628 629 detect_analog: 630 nv_encoder = find_encoder(connector, DCB_OUTPUT_ANALOG); 631 if (!nv_encoder && !nouveau_tv_disable) 632 nv_encoder = find_encoder(connector, DCB_OUTPUT_TV); 633 if (nv_encoder && force) { 634 struct drm_encoder *encoder = to_drm_encoder(nv_encoder); 635 const struct drm_encoder_helper_funcs *helper = 636 encoder->helper_private; 637 638 if (helper->detect(encoder, connector) == 639 connector_status_connected) { 640 nouveau_connector_set_encoder(connector, nv_encoder); 641 conn_status = connector_status_connected; 642 goto out; 643 } 644 645 } 646 647 out: 648 649 pm_runtime_mark_last_busy(connector->dev->dev); 650 pm_runtime_put_autosuspend(connector->dev->dev); 651 652 return conn_status; 653 } 654 655 static enum drm_connector_status 656 nouveau_connector_detect_lvds(struct drm_connector *connector, bool force) 657 { 658 struct drm_device *dev = connector->dev; 659 struct nouveau_drm *drm = nouveau_drm(dev); 660 struct nouveau_connector *nv_connector = nouveau_connector(connector); 661 struct nouveau_encoder *nv_encoder = NULL; 662 enum drm_connector_status status = connector_status_disconnected; 663 664 /* Cleanup the previous EDID block. */ 665 if (nv_connector->edid) { 666 drm_mode_connector_update_edid_property(connector, NULL); 667 kfree(nv_connector->edid); 668 nv_connector->edid = NULL; 669 } 670 671 nv_encoder = find_encoder(connector, DCB_OUTPUT_LVDS); 672 if (!nv_encoder) 673 return connector_status_disconnected; 674 675 /* Try retrieving EDID via DDC */ 676 if (!drm->vbios.fp_no_ddc) { 677 status = nouveau_connector_detect(connector, force); 678 if (status == connector_status_connected) 679 goto out; 680 } 681 682 /* On some laptops (Sony, i'm looking at you) there appears to 683 * be no direct way of accessing the panel's EDID. The only 684 * option available to us appears to be to ask ACPI for help.. 685 * 686 * It's important this check's before trying straps, one of the 687 * said manufacturer's laptops are configured in such a way 688 * the nouveau decides an entry in the VBIOS FP mode table is 689 * valid - it's not (rh#613284) 690 */ 691 if (nv_encoder->dcb->lvdsconf.use_acpi_for_edid) { 692 if ((nv_connector->edid = nouveau_acpi_edid(dev, connector))) { 693 status = connector_status_connected; 694 goto out; 695 } 696 } 697 698 /* If no EDID found above, and the VBIOS indicates a hardcoded 699 * modeline is avalilable for the panel, set it as the panel's 700 * native mode and exit. 701 */ 702 if (nouveau_bios_fp_mode(dev, NULL) && (drm->vbios.fp_no_ddc || 703 nv_encoder->dcb->lvdsconf.use_straps_for_mode)) { 704 status = connector_status_connected; 705 goto out; 706 } 707 708 /* Still nothing, some VBIOS images have a hardcoded EDID block 709 * stored for the panel stored in them. 710 */ 711 if (!drm->vbios.fp_no_ddc) { 712 struct edid *edid = 713 (struct edid *)nouveau_bios_embedded_edid(dev); 714 if (edid) { 715 nv_connector->edid = 716 kmemdup(edid, EDID_LENGTH, GFP_KERNEL); 717 if (nv_connector->edid) 718 status = connector_status_connected; 719 } 720 } 721 722 out: 723 #if defined(CONFIG_ACPI_BUTTON) || \ 724 (defined(CONFIG_ACPI_BUTTON_MODULE) && defined(MODULE)) 725 if (status == connector_status_connected && 726 !nouveau_ignorelid && !acpi_lid_open()) 727 status = connector_status_unknown; 728 #endif 729 730 drm_mode_connector_update_edid_property(connector, nv_connector->edid); 731 nouveau_connector_set_encoder(connector, nv_encoder); 732 return status; 733 } 734 735 static void 736 nouveau_connector_force(struct drm_connector *connector) 737 { 738 struct nouveau_drm *drm = nouveau_drm(connector->dev); 739 struct nouveau_connector *nv_connector = nouveau_connector(connector); 740 struct nouveau_encoder *nv_encoder; 741 int type; 742 743 if (nv_connector->type == DCB_CONNECTOR_DVI_I) { 744 if (connector->force == DRM_FORCE_ON_DIGITAL) 745 type = DCB_OUTPUT_TMDS; 746 else 747 type = DCB_OUTPUT_ANALOG; 748 } else 749 type = DCB_OUTPUT_ANY; 750 751 nv_encoder = find_encoder(connector, type); 752 if (!nv_encoder) { 753 NV_ERROR(drm, "can't find encoder to force %s on!\n", 754 connector->name); 755 connector->status = connector_status_disconnected; 756 return; 757 } 758 759 nouveau_connector_set_encoder(connector, nv_encoder); 760 } 761 762 static int 763 nouveau_connector_set_property(struct drm_connector *connector, 764 struct drm_property *property, uint64_t value) 765 { 766 struct nouveau_conn_atom *asyc = nouveau_conn_atom(connector->state); 767 struct nouveau_connector *nv_connector = nouveau_connector(connector); 768 struct nouveau_encoder *nv_encoder = nv_connector->detected_encoder; 769 struct drm_encoder *encoder = to_drm_encoder(nv_encoder); 770 int ret; 771 772 if (connector->dev->mode_config.funcs->atomic_commit) 773 return drm_atomic_helper_connector_set_property(connector, property, value); 774 775 ret = connector->funcs->atomic_set_property(&nv_connector->base, 776 &asyc->state, 777 property, value); 778 if (ret) { 779 if (nv_encoder && nv_encoder->dcb->type == DCB_OUTPUT_TV) 780 return get_slave_funcs(encoder)->set_property( 781 encoder, connector, property, value); 782 return ret; 783 } 784 785 nv_connector->scaling_mode = asyc->scaler.mode; 786 nv_connector->dithering_mode = asyc->dither.mode; 787 788 if (connector->encoder && connector->encoder->crtc) { 789 ret = drm_crtc_helper_set_mode(connector->encoder->crtc, 790 &connector->encoder->crtc->mode, 791 connector->encoder->crtc->x, 792 connector->encoder->crtc->y, 793 NULL); 794 if (!ret) 795 return -EINVAL; 796 } 797 798 return 0; 799 } 800 801 struct moderec { 802 int hdisplay; 803 int vdisplay; 804 }; 805 806 static struct moderec scaler_modes[] = { 807 { 1920, 1200 }, 808 { 1920, 1080 }, 809 { 1680, 1050 }, 810 { 1600, 1200 }, 811 { 1400, 1050 }, 812 { 1280, 1024 }, 813 { 1280, 960 }, 814 { 1152, 864 }, 815 { 1024, 768 }, 816 { 800, 600 }, 817 { 720, 400 }, 818 { 640, 480 }, 819 { 640, 400 }, 820 { 640, 350 }, 821 {} 822 }; 823 824 static int 825 nouveau_connector_scaler_modes_add(struct drm_connector *connector) 826 { 827 struct nouveau_connector *nv_connector = nouveau_connector(connector); 828 struct drm_display_mode *native = nv_connector->native_mode, *m; 829 struct drm_device *dev = connector->dev; 830 struct moderec *mode = &scaler_modes[0]; 831 int modes = 0; 832 833 if (!native) 834 return 0; 835 836 while (mode->hdisplay) { 837 if (mode->hdisplay <= native->hdisplay && 838 mode->vdisplay <= native->vdisplay && 839 (mode->hdisplay != native->hdisplay || 840 mode->vdisplay != native->vdisplay)) { 841 m = drm_cvt_mode(dev, mode->hdisplay, mode->vdisplay, 842 drm_mode_vrefresh(native), false, 843 false, false); 844 if (!m) 845 continue; 846 847 drm_mode_probed_add(connector, m); 848 modes++; 849 } 850 851 mode++; 852 } 853 854 return modes; 855 } 856 857 static void 858 nouveau_connector_detect_depth(struct drm_connector *connector) 859 { 860 struct nouveau_drm *drm = nouveau_drm(connector->dev); 861 struct nouveau_connector *nv_connector = nouveau_connector(connector); 862 struct nouveau_encoder *nv_encoder = nv_connector->detected_encoder; 863 struct nvbios *bios = &drm->vbios; 864 struct drm_display_mode *mode = nv_connector->native_mode; 865 bool duallink; 866 867 /* if the edid is feeling nice enough to provide this info, use it */ 868 if (nv_connector->edid && connector->display_info.bpc) 869 return; 870 871 /* EDID 1.4 is *supposed* to be supported on eDP, but, Apple... */ 872 if (nv_connector->type == DCB_CONNECTOR_eDP) { 873 connector->display_info.bpc = 6; 874 return; 875 } 876 877 /* we're out of options unless we're LVDS, default to 8bpc */ 878 if (nv_encoder->dcb->type != DCB_OUTPUT_LVDS) { 879 connector->display_info.bpc = 8; 880 return; 881 } 882 883 connector->display_info.bpc = 6; 884 885 /* LVDS: panel straps */ 886 if (bios->fp_no_ddc) { 887 if (bios->fp.if_is_24bit) 888 connector->display_info.bpc = 8; 889 return; 890 } 891 892 /* LVDS: DDC panel, need to first determine the number of links to 893 * know which if_is_24bit flag to check... 894 */ 895 if (nv_connector->edid && 896 nv_connector->type == DCB_CONNECTOR_LVDS_SPWG) 897 duallink = ((u8 *)nv_connector->edid)[121] == 2; 898 else 899 duallink = mode->clock >= bios->fp.duallink_transition_clk; 900 901 if ((!duallink && (bios->fp.strapless_is_24bit & 1)) || 902 ( duallink && (bios->fp.strapless_is_24bit & 2))) 903 connector->display_info.bpc = 8; 904 } 905 906 static int 907 nouveau_connector_get_modes(struct drm_connector *connector) 908 { 909 struct drm_device *dev = connector->dev; 910 struct nouveau_drm *drm = nouveau_drm(dev); 911 struct nouveau_connector *nv_connector = nouveau_connector(connector); 912 struct nouveau_encoder *nv_encoder = nv_connector->detected_encoder; 913 struct drm_encoder *encoder = to_drm_encoder(nv_encoder); 914 int ret = 0; 915 916 /* destroy the native mode, the attached monitor could have changed. 917 */ 918 if (nv_connector->native_mode) { 919 drm_mode_destroy(dev, nv_connector->native_mode); 920 nv_connector->native_mode = NULL; 921 } 922 923 if (nv_connector->edid) 924 ret = drm_add_edid_modes(connector, nv_connector->edid); 925 else 926 if (nv_encoder->dcb->type == DCB_OUTPUT_LVDS && 927 (nv_encoder->dcb->lvdsconf.use_straps_for_mode || 928 drm->vbios.fp_no_ddc) && nouveau_bios_fp_mode(dev, NULL)) { 929 struct drm_display_mode mode; 930 931 nouveau_bios_fp_mode(dev, &mode); 932 nv_connector->native_mode = drm_mode_duplicate(dev, &mode); 933 } 934 935 /* Determine display colour depth for everything except LVDS now, 936 * DP requires this before mode_valid() is called. 937 */ 938 if (connector->connector_type != DRM_MODE_CONNECTOR_LVDS) 939 nouveau_connector_detect_depth(connector); 940 941 /* Find the native mode if this is a digital panel, if we didn't 942 * find any modes through DDC previously add the native mode to 943 * the list of modes. 944 */ 945 if (!nv_connector->native_mode) 946 nv_connector->native_mode = nouveau_conn_native_mode(connector); 947 if (ret == 0 && nv_connector->native_mode) { 948 struct drm_display_mode *mode; 949 950 mode = drm_mode_duplicate(dev, nv_connector->native_mode); 951 drm_mode_probed_add(connector, mode); 952 ret = 1; 953 } 954 955 /* Determine LVDS colour depth, must happen after determining 956 * "native" mode as some VBIOS tables require us to use the 957 * pixel clock as part of the lookup... 958 */ 959 if (connector->connector_type == DRM_MODE_CONNECTOR_LVDS) 960 nouveau_connector_detect_depth(connector); 961 962 if (nv_encoder->dcb->type == DCB_OUTPUT_TV) 963 ret = get_slave_funcs(encoder)->get_modes(encoder, connector); 964 965 if (nv_connector->type == DCB_CONNECTOR_LVDS || 966 nv_connector->type == DCB_CONNECTOR_LVDS_SPWG || 967 nv_connector->type == DCB_CONNECTOR_eDP) 968 ret += nouveau_connector_scaler_modes_add(connector); 969 970 return ret; 971 } 972 973 static unsigned 974 get_tmds_link_bandwidth(struct drm_connector *connector, bool hdmi) 975 { 976 struct nouveau_connector *nv_connector = nouveau_connector(connector); 977 struct nouveau_drm *drm = nouveau_drm(connector->dev); 978 struct dcb_output *dcb = nv_connector->detected_encoder->dcb; 979 980 if (hdmi) { 981 if (nouveau_hdmimhz > 0) 982 return nouveau_hdmimhz * 1000; 983 /* Note: these limits are conservative, some Fermi's 984 * can do 297 MHz. Unclear how this can be determined. 985 */ 986 if (drm->device.info.family >= NV_DEVICE_INFO_V0_KEPLER) 987 return 297000; 988 if (drm->device.info.family >= NV_DEVICE_INFO_V0_FERMI) 989 return 225000; 990 } 991 if (dcb->location != DCB_LOC_ON_CHIP || 992 drm->device.info.chipset >= 0x46) 993 return 165000; 994 else if (drm->device.info.chipset >= 0x40) 995 return 155000; 996 else if (drm->device.info.chipset >= 0x18) 997 return 135000; 998 else 999 return 112000; 1000 } 1001 1002 static int 1003 nouveau_connector_mode_valid(struct drm_connector *connector, 1004 struct drm_display_mode *mode) 1005 { 1006 struct nouveau_connector *nv_connector = nouveau_connector(connector); 1007 struct nouveau_encoder *nv_encoder = nv_connector->detected_encoder; 1008 struct drm_encoder *encoder = to_drm_encoder(nv_encoder); 1009 unsigned min_clock = 25000, max_clock = min_clock; 1010 unsigned clock = mode->clock; 1011 bool hdmi; 1012 1013 switch (nv_encoder->dcb->type) { 1014 case DCB_OUTPUT_LVDS: 1015 if (nv_connector->native_mode && 1016 (mode->hdisplay > nv_connector->native_mode->hdisplay || 1017 mode->vdisplay > nv_connector->native_mode->vdisplay)) 1018 return MODE_PANEL; 1019 1020 min_clock = 0; 1021 max_clock = 400000; 1022 break; 1023 case DCB_OUTPUT_TMDS: 1024 hdmi = drm_detect_hdmi_monitor(nv_connector->edid); 1025 max_clock = get_tmds_link_bandwidth(connector, hdmi); 1026 if (!hdmi && nouveau_duallink && 1027 nv_encoder->dcb->duallink_possible) 1028 max_clock *= 2; 1029 break; 1030 case DCB_OUTPUT_ANALOG: 1031 max_clock = nv_encoder->dcb->crtconf.maxfreq; 1032 if (!max_clock) 1033 max_clock = 350000; 1034 break; 1035 case DCB_OUTPUT_TV: 1036 return get_slave_funcs(encoder)->mode_valid(encoder, mode); 1037 case DCB_OUTPUT_DP: 1038 max_clock = nv_encoder->dp.link_nr; 1039 max_clock *= nv_encoder->dp.link_bw; 1040 clock = clock * (connector->display_info.bpc * 3) / 10; 1041 break; 1042 default: 1043 BUG_ON(1); 1044 return MODE_BAD; 1045 } 1046 1047 if (clock < min_clock) 1048 return MODE_CLOCK_LOW; 1049 1050 if (clock > max_clock) 1051 return MODE_CLOCK_HIGH; 1052 1053 return MODE_OK; 1054 } 1055 1056 static struct drm_encoder * 1057 nouveau_connector_best_encoder(struct drm_connector *connector) 1058 { 1059 struct nouveau_connector *nv_connector = nouveau_connector(connector); 1060 1061 if (nv_connector->detected_encoder) 1062 return to_drm_encoder(nv_connector->detected_encoder); 1063 1064 return NULL; 1065 } 1066 1067 static const struct drm_connector_helper_funcs 1068 nouveau_connector_helper_funcs = { 1069 .get_modes = nouveau_connector_get_modes, 1070 .mode_valid = nouveau_connector_mode_valid, 1071 .best_encoder = nouveau_connector_best_encoder, 1072 }; 1073 1074 static int 1075 nouveau_connector_dpms(struct drm_connector *connector, int mode) 1076 { 1077 if (connector->dev->mode_config.funcs->atomic_commit) 1078 return drm_atomic_helper_connector_dpms(connector, mode); 1079 return drm_helper_connector_dpms(connector, mode); 1080 } 1081 1082 static const struct drm_connector_funcs 1083 nouveau_connector_funcs = { 1084 .dpms = nouveau_connector_dpms, 1085 .reset = nouveau_conn_reset, 1086 .detect = nouveau_connector_detect, 1087 .force = nouveau_connector_force, 1088 .fill_modes = drm_helper_probe_single_connector_modes, 1089 .set_property = nouveau_connector_set_property, 1090 .destroy = nouveau_connector_destroy, 1091 .atomic_duplicate_state = nouveau_conn_atomic_duplicate_state, 1092 .atomic_destroy_state = nouveau_conn_atomic_destroy_state, 1093 .atomic_set_property = nouveau_conn_atomic_set_property, 1094 .atomic_get_property = nouveau_conn_atomic_get_property, 1095 }; 1096 1097 static const struct drm_connector_funcs 1098 nouveau_connector_funcs_lvds = { 1099 .dpms = nouveau_connector_dpms, 1100 .reset = nouveau_conn_reset, 1101 .detect = nouveau_connector_detect_lvds, 1102 .force = nouveau_connector_force, 1103 .fill_modes = drm_helper_probe_single_connector_modes, 1104 .set_property = nouveau_connector_set_property, 1105 .destroy = nouveau_connector_destroy, 1106 .atomic_duplicate_state = nouveau_conn_atomic_duplicate_state, 1107 .atomic_destroy_state = nouveau_conn_atomic_destroy_state, 1108 .atomic_set_property = nouveau_conn_atomic_set_property, 1109 .atomic_get_property = nouveau_conn_atomic_get_property, 1110 }; 1111 1112 static int 1113 nouveau_connector_hotplug(struct nvif_notify *notify) 1114 { 1115 struct nouveau_connector *nv_connector = 1116 container_of(notify, typeof(*nv_connector), hpd); 1117 struct drm_connector *connector = &nv_connector->base; 1118 struct nouveau_drm *drm = nouveau_drm(connector->dev); 1119 const struct nvif_notify_conn_rep_v0 *rep = notify->data; 1120 const char *name = connector->name; 1121 struct nouveau_encoder *nv_encoder; 1122 1123 if (rep->mask & NVIF_NOTIFY_CONN_V0_IRQ) { 1124 NV_DEBUG(drm, "service %s\n", name); 1125 if ((nv_encoder = find_encoder(connector, DCB_OUTPUT_DP))) 1126 nv50_mstm_service(nv_encoder->dp.mstm); 1127 } else { 1128 bool plugged = (rep->mask != NVIF_NOTIFY_CONN_V0_UNPLUG); 1129 1130 NV_DEBUG(drm, "%splugged %s\n", plugged ? "" : "un", name); 1131 if ((nv_encoder = find_encoder(connector, DCB_OUTPUT_DP))) { 1132 if (!plugged) 1133 nv50_mstm_remove(nv_encoder->dp.mstm); 1134 } 1135 1136 drm_helper_hpd_irq_event(connector->dev); 1137 } 1138 1139 return NVIF_NOTIFY_KEEP; 1140 } 1141 1142 static ssize_t 1143 nouveau_connector_aux_xfer(struct drm_dp_aux *obj, struct drm_dp_aux_msg *msg) 1144 { 1145 struct nouveau_connector *nv_connector = 1146 container_of(obj, typeof(*nv_connector), aux); 1147 struct nouveau_encoder *nv_encoder; 1148 struct nvkm_i2c_aux *aux; 1149 int ret; 1150 1151 nv_encoder = find_encoder(&nv_connector->base, DCB_OUTPUT_DP); 1152 if (!nv_encoder || !(aux = nv_encoder->aux)) 1153 return -ENODEV; 1154 if (WARN_ON(msg->size > 16)) 1155 return -E2BIG; 1156 if (msg->size == 0) 1157 return msg->size; 1158 1159 ret = nvkm_i2c_aux_acquire(aux); 1160 if (ret) 1161 return ret; 1162 1163 ret = nvkm_i2c_aux_xfer(aux, false, msg->request, msg->address, 1164 msg->buffer, msg->size); 1165 nvkm_i2c_aux_release(aux); 1166 if (ret >= 0) { 1167 msg->reply = ret; 1168 return msg->size; 1169 } 1170 1171 return ret; 1172 } 1173 1174 static int 1175 drm_conntype_from_dcb(enum dcb_connector_type dcb) 1176 { 1177 switch (dcb) { 1178 case DCB_CONNECTOR_VGA : return DRM_MODE_CONNECTOR_VGA; 1179 case DCB_CONNECTOR_TV_0 : 1180 case DCB_CONNECTOR_TV_1 : 1181 case DCB_CONNECTOR_TV_3 : return DRM_MODE_CONNECTOR_TV; 1182 case DCB_CONNECTOR_DMS59_0 : 1183 case DCB_CONNECTOR_DMS59_1 : 1184 case DCB_CONNECTOR_DVI_I : return DRM_MODE_CONNECTOR_DVII; 1185 case DCB_CONNECTOR_DVI_D : return DRM_MODE_CONNECTOR_DVID; 1186 case DCB_CONNECTOR_LVDS : 1187 case DCB_CONNECTOR_LVDS_SPWG: return DRM_MODE_CONNECTOR_LVDS; 1188 case DCB_CONNECTOR_DMS59_DP0: 1189 case DCB_CONNECTOR_DMS59_DP1: 1190 case DCB_CONNECTOR_DP : return DRM_MODE_CONNECTOR_DisplayPort; 1191 case DCB_CONNECTOR_eDP : return DRM_MODE_CONNECTOR_eDP; 1192 case DCB_CONNECTOR_HDMI_0 : 1193 case DCB_CONNECTOR_HDMI_1 : 1194 case DCB_CONNECTOR_HDMI_C : return DRM_MODE_CONNECTOR_HDMIA; 1195 default: 1196 break; 1197 } 1198 1199 return DRM_MODE_CONNECTOR_Unknown; 1200 } 1201 1202 struct drm_connector * 1203 nouveau_connector_create(struct drm_device *dev, int index) 1204 { 1205 const struct drm_connector_funcs *funcs = &nouveau_connector_funcs; 1206 struct nouveau_drm *drm = nouveau_drm(dev); 1207 struct nouveau_display *disp = nouveau_display(dev); 1208 struct nouveau_connector *nv_connector = NULL; 1209 struct drm_connector *connector; 1210 int type, ret = 0; 1211 bool dummy; 1212 1213 list_for_each_entry(connector, &dev->mode_config.connector_list, head) { 1214 nv_connector = nouveau_connector(connector); 1215 if (nv_connector->index == index) 1216 return connector; 1217 } 1218 1219 nv_connector = kzalloc(sizeof(*nv_connector), GFP_KERNEL); 1220 if (!nv_connector) 1221 return ERR_PTR(-ENOMEM); 1222 1223 connector = &nv_connector->base; 1224 nv_connector->index = index; 1225 1226 /* attempt to parse vbios connector type and hotplug gpio */ 1227 nv_connector->dcb = olddcb_conn(dev, index); 1228 if (nv_connector->dcb) { 1229 u32 entry = ROM16(nv_connector->dcb[0]); 1230 if (olddcb_conntab(dev)[3] >= 4) 1231 entry |= (u32)ROM16(nv_connector->dcb[2]) << 16; 1232 1233 nv_connector->type = nv_connector->dcb[0]; 1234 if (drm_conntype_from_dcb(nv_connector->type) == 1235 DRM_MODE_CONNECTOR_Unknown) { 1236 NV_WARN(drm, "unknown connector type %02x\n", 1237 nv_connector->type); 1238 nv_connector->type = DCB_CONNECTOR_NONE; 1239 } 1240 1241 /* Gigabyte NX85T */ 1242 if (nv_match_device(dev, 0x0421, 0x1458, 0x344c)) { 1243 if (nv_connector->type == DCB_CONNECTOR_HDMI_1) 1244 nv_connector->type = DCB_CONNECTOR_DVI_I; 1245 } 1246 1247 /* Gigabyte GV-NX86T512H */ 1248 if (nv_match_device(dev, 0x0402, 0x1458, 0x3455)) { 1249 if (nv_connector->type == DCB_CONNECTOR_HDMI_1) 1250 nv_connector->type = DCB_CONNECTOR_DVI_I; 1251 } 1252 } else { 1253 nv_connector->type = DCB_CONNECTOR_NONE; 1254 } 1255 1256 /* no vbios data, or an unknown dcb connector type - attempt to 1257 * figure out something suitable ourselves 1258 */ 1259 if (nv_connector->type == DCB_CONNECTOR_NONE) { 1260 struct nouveau_drm *drm = nouveau_drm(dev); 1261 struct dcb_table *dcbt = &drm->vbios.dcb; 1262 u32 encoders = 0; 1263 int i; 1264 1265 for (i = 0; i < dcbt->entries; i++) { 1266 if (dcbt->entry[i].connector == nv_connector->index) 1267 encoders |= (1 << dcbt->entry[i].type); 1268 } 1269 1270 if (encoders & (1 << DCB_OUTPUT_DP)) { 1271 if (encoders & (1 << DCB_OUTPUT_TMDS)) 1272 nv_connector->type = DCB_CONNECTOR_DP; 1273 else 1274 nv_connector->type = DCB_CONNECTOR_eDP; 1275 } else 1276 if (encoders & (1 << DCB_OUTPUT_TMDS)) { 1277 if (encoders & (1 << DCB_OUTPUT_ANALOG)) 1278 nv_connector->type = DCB_CONNECTOR_DVI_I; 1279 else 1280 nv_connector->type = DCB_CONNECTOR_DVI_D; 1281 } else 1282 if (encoders & (1 << DCB_OUTPUT_ANALOG)) { 1283 nv_connector->type = DCB_CONNECTOR_VGA; 1284 } else 1285 if (encoders & (1 << DCB_OUTPUT_LVDS)) { 1286 nv_connector->type = DCB_CONNECTOR_LVDS; 1287 } else 1288 if (encoders & (1 << DCB_OUTPUT_TV)) { 1289 nv_connector->type = DCB_CONNECTOR_TV_0; 1290 } 1291 } 1292 1293 switch ((type = drm_conntype_from_dcb(nv_connector->type))) { 1294 case DRM_MODE_CONNECTOR_LVDS: 1295 ret = nouveau_bios_parse_lvds_table(dev, 0, &dummy, &dummy); 1296 if (ret) { 1297 NV_ERROR(drm, "Error parsing LVDS table, disabling\n"); 1298 kfree(nv_connector); 1299 return ERR_PTR(ret); 1300 } 1301 1302 funcs = &nouveau_connector_funcs_lvds; 1303 break; 1304 case DRM_MODE_CONNECTOR_DisplayPort: 1305 case DRM_MODE_CONNECTOR_eDP: 1306 nv_connector->aux.dev = dev->dev; 1307 nv_connector->aux.transfer = nouveau_connector_aux_xfer; 1308 ret = drm_dp_aux_register(&nv_connector->aux); 1309 if (ret) { 1310 NV_ERROR(drm, "failed to register aux channel\n"); 1311 kfree(nv_connector); 1312 return ERR_PTR(ret); 1313 } 1314 1315 funcs = &nouveau_connector_funcs; 1316 break; 1317 default: 1318 funcs = &nouveau_connector_funcs; 1319 break; 1320 } 1321 1322 /* defaults, will get overridden in detect() */ 1323 connector->interlace_allowed = false; 1324 connector->doublescan_allowed = false; 1325 1326 drm_connector_init(dev, connector, funcs, type); 1327 drm_connector_helper_add(connector, &nouveau_connector_helper_funcs); 1328 1329 connector->funcs->reset(connector); 1330 nouveau_conn_attach_properties(connector); 1331 1332 /* Default scaling mode */ 1333 switch (nv_connector->type) { 1334 case DCB_CONNECTOR_LVDS: 1335 case DCB_CONNECTOR_LVDS_SPWG: 1336 case DCB_CONNECTOR_eDP: 1337 /* see note in nouveau_connector_set_property() */ 1338 if (disp->disp.oclass < NV50_DISP) { 1339 nv_connector->scaling_mode = DRM_MODE_SCALE_FULLSCREEN; 1340 break; 1341 } 1342 nv_connector->scaling_mode = DRM_MODE_SCALE_NONE; 1343 break; 1344 default: 1345 nv_connector->scaling_mode = DRM_MODE_SCALE_NONE; 1346 break; 1347 } 1348 1349 /* dithering properties */ 1350 switch (nv_connector->type) { 1351 case DCB_CONNECTOR_TV_0: 1352 case DCB_CONNECTOR_TV_1: 1353 case DCB_CONNECTOR_TV_3: 1354 case DCB_CONNECTOR_VGA: 1355 break; 1356 default: 1357 nv_connector->dithering_mode = DITHERING_MODE_AUTO; 1358 break; 1359 } 1360 1361 ret = nvif_notify_init(&disp->disp, nouveau_connector_hotplug, true, 1362 NV04_DISP_NTFY_CONN, 1363 &(struct nvif_notify_conn_req_v0) { 1364 .mask = NVIF_NOTIFY_CONN_V0_ANY, 1365 .conn = index, 1366 }, 1367 sizeof(struct nvif_notify_conn_req_v0), 1368 sizeof(struct nvif_notify_conn_rep_v0), 1369 &nv_connector->hpd); 1370 if (ret) 1371 connector->polled = DRM_CONNECTOR_POLL_CONNECT; 1372 else 1373 connector->polled = DRM_CONNECTOR_POLL_HPD; 1374 1375 drm_connector_register(connector); 1376 return connector; 1377 } 1378