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