2 * Copyright (C) 2008 Maarten Maathuis.
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:
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.
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.
27 #include <acpi/button.h>
29 #include <linux/pm_runtime.h>
30 #include <linux/vga_switcheroo.h>
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>
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"
44 #include "nouveau_display.h"
45 #include "nouveau_connector.h"
46 #include "nouveau_encoder.h"
47 #include "nouveau_crtc.h"
49 #include <nvif/class.h>
50 #include <nvif/cl0046.h>
51 #include <nvif/event.h>
53 struct drm_display_mode
*
54 nouveau_conn_native_mode(struct drm_connector
*connector
)
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;
62 list_for_each_entry(mode
, &connector
->probed_modes
, head
) {
63 if (helper
->mode_valid(connector
, mode
) != MODE_OK
||
64 (mode
->flags
& DRM_MODE_FLAG_INTERLACE
))
67 /* Use preferred mode if there is one.. */
68 if (mode
->type
& DRM_MODE_TYPE_PREFERRED
) {
69 NV_DEBUG(drm
, "native mode from preferred\n");
70 return drm_mode_duplicate(dev
, mode
);
73 /* Otherwise, take the resolution with the largest width, then
74 * height, then vertical refresh
76 if (mode
->hdisplay
< high_w
)
79 if (mode
->hdisplay
== high_w
&& mode
->vdisplay
< high_h
)
82 if (mode
->hdisplay
== high_w
&& mode
->vdisplay
== high_h
&&
83 drm_mode_vrefresh(mode
) < high_v
)
86 high_w
= mode
->hdisplay
;
87 high_h
= mode
->vdisplay
;
88 high_v
= drm_mode_vrefresh(mode
);
92 NV_DEBUG(drm
, "native mode from largest: %dx%d@%d\n",
93 high_w
, high_h
, high_v
);
94 return largest
? drm_mode_duplicate(dev
, largest
) : NULL
;
98 nouveau_conn_atomic_get_property(struct drm_connector
*connector
,
99 const struct drm_connector_state
*state
,
100 struct drm_property
*property
, u64
*val
)
102 struct nouveau_conn_atom
*asyc
= nouveau_conn_atom(state
);
103 struct nouveau_display
*disp
= nouveau_display(connector
->dev
);
104 struct drm_device
*dev
= connector
->dev
;
106 if (property
== dev
->mode_config
.scaling_mode_property
)
107 *val
= asyc
->scaler
.mode
;
108 else if (property
== disp
->underscan_property
)
109 *val
= asyc
->scaler
.underscan
.mode
;
110 else if (property
== disp
->underscan_hborder_property
)
111 *val
= asyc
->scaler
.underscan
.hborder
;
112 else if (property
== disp
->underscan_vborder_property
)
113 *val
= asyc
->scaler
.underscan
.vborder
;
114 else if (property
== disp
->dithering_mode
)
115 *val
= asyc
->dither
.mode
;
116 else if (property
== disp
->dithering_depth
)
117 *val
= asyc
->dither
.depth
;
118 else if (property
== disp
->vibrant_hue_property
)
119 *val
= asyc
->procamp
.vibrant_hue
;
120 else if (property
== disp
->color_vibrance_property
)
121 *val
= asyc
->procamp
.color_vibrance
;
129 nouveau_conn_atomic_set_property(struct drm_connector
*connector
,
130 struct drm_connector_state
*state
,
131 struct drm_property
*property
, u64 val
)
133 struct drm_device
*dev
= connector
->dev
;
134 struct nouveau_conn_atom
*asyc
= nouveau_conn_atom(state
);
135 struct nouveau_display
*disp
= nouveau_display(dev
);
137 if (property
== dev
->mode_config
.scaling_mode_property
) {
139 case DRM_MODE_SCALE_NONE
:
140 /* We allow 'None' for EDID modes, even on a fixed
141 * panel (some exist with support for lower refresh
142 * rates, which people might want to use for power-
145 * Non-EDID modes will force the use of GPU scaling
146 * to the native mode regardless of this setting.
148 switch (connector
->connector_type
) {
149 case DRM_MODE_CONNECTOR_LVDS
:
150 case DRM_MODE_CONNECTOR_eDP
:
151 /* ... except prior to G80, where the code
152 * doesn't support such things.
154 if (disp
->disp
.object
.oclass
< NV50_DISP
)
160 case DRM_MODE_SCALE_FULLSCREEN
:
161 case DRM_MODE_SCALE_CENTER
:
162 case DRM_MODE_SCALE_ASPECT
:
168 if (asyc
->scaler
.mode
!= val
) {
169 asyc
->scaler
.mode
= val
;
170 asyc
->set
.scaler
= true;
173 if (property
== disp
->underscan_property
) {
174 if (asyc
->scaler
.underscan
.mode
!= val
) {
175 asyc
->scaler
.underscan
.mode
= val
;
176 asyc
->set
.scaler
= true;
179 if (property
== disp
->underscan_hborder_property
) {
180 if (asyc
->scaler
.underscan
.hborder
!= val
) {
181 asyc
->scaler
.underscan
.hborder
= val
;
182 asyc
->set
.scaler
= true;
185 if (property
== disp
->underscan_vborder_property
) {
186 if (asyc
->scaler
.underscan
.vborder
!= val
) {
187 asyc
->scaler
.underscan
.vborder
= val
;
188 asyc
->set
.scaler
= true;
191 if (property
== disp
->dithering_mode
) {
192 if (asyc
->dither
.mode
!= val
) {
193 asyc
->dither
.mode
= val
;
194 asyc
->set
.dither
= true;
197 if (property
== disp
->dithering_depth
) {
198 if (asyc
->dither
.mode
!= val
) {
199 asyc
->dither
.depth
= val
;
200 asyc
->set
.dither
= true;
203 if (property
== disp
->vibrant_hue_property
) {
204 if (asyc
->procamp
.vibrant_hue
!= val
) {
205 asyc
->procamp
.vibrant_hue
= val
;
206 asyc
->set
.procamp
= true;
209 if (property
== disp
->color_vibrance_property
) {
210 if (asyc
->procamp
.color_vibrance
!= val
) {
211 asyc
->procamp
.color_vibrance
= val
;
212 asyc
->set
.procamp
= true;
222 nouveau_conn_atomic_destroy_state(struct drm_connector
*connector
,
223 struct drm_connector_state
*state
)
225 struct nouveau_conn_atom
*asyc
= nouveau_conn_atom(state
);
226 __drm_atomic_helper_connector_destroy_state(&asyc
->state
);
230 struct drm_connector_state
*
231 nouveau_conn_atomic_duplicate_state(struct drm_connector
*connector
)
233 struct nouveau_conn_atom
*armc
= nouveau_conn_atom(connector
->state
);
234 struct nouveau_conn_atom
*asyc
;
235 if (!(asyc
= kmalloc(sizeof(*asyc
), GFP_KERNEL
)))
237 __drm_atomic_helper_connector_duplicate_state(connector
, &asyc
->state
);
238 asyc
->dither
= armc
->dither
;
239 asyc
->scaler
= armc
->scaler
;
240 asyc
->procamp
= armc
->procamp
;
246 nouveau_conn_reset(struct drm_connector
*connector
)
248 struct nouveau_connector
*nv_connector
= nouveau_connector(connector
);
249 struct nouveau_conn_atom
*asyc
;
251 if (drm_drv_uses_atomic_modeset(connector
->dev
)) {
252 if (WARN_ON(!(asyc
= kzalloc(sizeof(*asyc
), GFP_KERNEL
))))
255 if (connector
->state
)
256 nouveau_conn_atomic_destroy_state(connector
,
259 __drm_atomic_helper_connector_reset(connector
, &asyc
->state
);
261 asyc
= &nv_connector
->properties_state
;
264 asyc
->dither
.mode
= DITHERING_MODE_AUTO
;
265 asyc
->dither
.depth
= DITHERING_DEPTH_AUTO
;
266 asyc
->scaler
.mode
= DRM_MODE_SCALE_NONE
;
267 asyc
->scaler
.underscan
.mode
= UNDERSCAN_OFF
;
268 asyc
->procamp
.color_vibrance
= 150;
269 asyc
->procamp
.vibrant_hue
= 90;
271 if (nouveau_display(connector
->dev
)->disp
.object
.oclass
< NV50_DISP
) {
272 switch (connector
->connector_type
) {
273 case DRM_MODE_CONNECTOR_LVDS
:
274 /* See note in nouveau_conn_atomic_set_property(). */
275 asyc
->scaler
.mode
= DRM_MODE_SCALE_FULLSCREEN
;
284 nouveau_conn_attach_properties(struct drm_connector
*connector
)
286 struct drm_device
*dev
= connector
->dev
;
287 struct nouveau_display
*disp
= nouveau_display(dev
);
288 struct nouveau_connector
*nv_connector
= nouveau_connector(connector
);
289 struct nouveau_conn_atom
*armc
;
291 if (drm_drv_uses_atomic_modeset(connector
->dev
))
292 armc
= nouveau_conn_atom(connector
->state
);
294 armc
= &nv_connector
->properties_state
;
296 /* Init DVI-I specific properties. */
297 if (connector
->connector_type
== DRM_MODE_CONNECTOR_DVII
)
298 drm_object_attach_property(&connector
->base
, dev
->mode_config
.
299 dvi_i_subconnector_property
, 0);
301 /* Add overscan compensation options to digital outputs. */
302 if (disp
->underscan_property
&&
303 (connector
->connector_type
== DRM_MODE_CONNECTOR_DVID
||
304 connector
->connector_type
== DRM_MODE_CONNECTOR_DVII
||
305 connector
->connector_type
== DRM_MODE_CONNECTOR_HDMIA
||
306 connector
->connector_type
== DRM_MODE_CONNECTOR_DisplayPort
)) {
307 drm_object_attach_property(&connector
->base
,
308 disp
->underscan_property
,
310 drm_object_attach_property(&connector
->base
,
311 disp
->underscan_hborder_property
, 0);
312 drm_object_attach_property(&connector
->base
,
313 disp
->underscan_vborder_property
, 0);
316 /* Add hue and saturation options. */
317 if (disp
->vibrant_hue_property
)
318 drm_object_attach_property(&connector
->base
,
319 disp
->vibrant_hue_property
,
320 armc
->procamp
.vibrant_hue
);
321 if (disp
->color_vibrance_property
)
322 drm_object_attach_property(&connector
->base
,
323 disp
->color_vibrance_property
,
324 armc
->procamp
.color_vibrance
);
326 /* Scaling mode property. */
327 switch (connector
->connector_type
) {
328 case DRM_MODE_CONNECTOR_TV
:
330 case DRM_MODE_CONNECTOR_VGA
:
331 if (disp
->disp
.object
.oclass
< NV50_DISP
)
332 break; /* Can only scale on DFPs. */
335 drm_object_attach_property(&connector
->base
, dev
->mode_config
.
336 scaling_mode_property
,
341 /* Dithering properties. */
342 switch (connector
->connector_type
) {
343 case DRM_MODE_CONNECTOR_TV
:
344 case DRM_MODE_CONNECTOR_VGA
:
347 if (disp
->dithering_mode
) {
348 drm_object_attach_property(&connector
->base
,
349 disp
->dithering_mode
,
352 if (disp
->dithering_depth
) {
353 drm_object_attach_property(&connector
->base
,
354 disp
->dithering_depth
,
361 MODULE_PARM_DESC(tv_disable
, "Disable TV-out detection");
362 int nouveau_tv_disable
= 0;
363 module_param_named(tv_disable
, nouveau_tv_disable
, int, 0400);
365 MODULE_PARM_DESC(ignorelid
, "Ignore ACPI lid status");
366 int nouveau_ignorelid
= 0;
367 module_param_named(ignorelid
, nouveau_ignorelid
, int, 0400);
369 MODULE_PARM_DESC(duallink
, "Allow dual-link TMDS (default: enabled)");
370 int nouveau_duallink
= 1;
371 module_param_named(duallink
, nouveau_duallink
, int, 0400);
373 MODULE_PARM_DESC(hdmimhz
, "Force a maximum HDMI pixel clock (in MHz)");
374 int nouveau_hdmimhz
= 0;
375 module_param_named(hdmimhz
, nouveau_hdmimhz
, int, 0400);
377 struct nouveau_encoder
*
378 find_encoder(struct drm_connector
*connector
, int type
)
380 struct nouveau_encoder
*nv_encoder
;
381 struct drm_encoder
*enc
;
383 drm_connector_for_each_possible_encoder(connector
, enc
) {
384 nv_encoder
= nouveau_encoder(enc
);
386 if (type
== DCB_OUTPUT_ANY
||
387 (nv_encoder
->dcb
&& nv_encoder
->dcb
->type
== type
))
394 struct nouveau_connector
*
395 nouveau_encoder_connector_get(struct nouveau_encoder
*encoder
)
397 struct drm_device
*dev
= to_drm_encoder(encoder
)->dev
;
398 struct drm_connector
*drm_connector
;
400 list_for_each_entry(drm_connector
, &dev
->mode_config
.connector_list
, head
) {
401 if (drm_connector
->encoder
== to_drm_encoder(encoder
))
402 return nouveau_connector(drm_connector
);
409 nouveau_connector_destroy(struct drm_connector
*connector
)
411 struct nouveau_connector
*nv_connector
= nouveau_connector(connector
);
412 nvif_notify_fini(&nv_connector
->hpd
);
413 kfree(nv_connector
->edid
);
414 drm_connector_unregister(connector
);
415 drm_connector_cleanup(connector
);
416 if (nv_connector
->aux
.transfer
) {
417 drm_dp_cec_unregister_connector(&nv_connector
->aux
);
418 drm_dp_aux_unregister(&nv_connector
->aux
);
419 kfree(nv_connector
->aux
.name
);
424 static struct nouveau_encoder
*
425 nouveau_connector_ddc_detect(struct drm_connector
*connector
)
427 struct drm_device
*dev
= connector
->dev
;
428 struct nouveau_encoder
*nv_encoder
= NULL
, *found
= NULL
;
429 struct drm_encoder
*encoder
;
431 bool switcheroo_ddc
= false;
433 drm_connector_for_each_possible_encoder(connector
, encoder
) {
434 nv_encoder
= nouveau_encoder(encoder
);
436 switch (nv_encoder
->dcb
->type
) {
438 ret
= nouveau_dp_detect(nv_encoder
);
439 if (ret
== NOUVEAU_DP_MST
)
441 else if (ret
== NOUVEAU_DP_SST
)
445 case DCB_OUTPUT_LVDS
:
446 switcheroo_ddc
= !!(vga_switcheroo_handler_flags() &
447 VGA_SWITCHEROO_CAN_SWITCH_DDC
);
450 if (!nv_encoder
->i2c
)
454 vga_switcheroo_lock_ddc(dev
->pdev
);
455 if (nvkm_probe_i2c(nv_encoder
->i2c
, 0x50))
458 vga_switcheroo_unlock_ddc(dev
->pdev
);
469 static struct nouveau_encoder
*
470 nouveau_connector_of_detect(struct drm_connector
*connector
)
473 struct drm_device
*dev
= connector
->dev
;
474 struct nouveau_connector
*nv_connector
= nouveau_connector(connector
);
475 struct nouveau_encoder
*nv_encoder
;
476 struct device_node
*cn
, *dn
= pci_device_to_OF_node(dev
->pdev
);
479 !((nv_encoder
= find_encoder(connector
, DCB_OUTPUT_TMDS
)) ||
480 (nv_encoder
= find_encoder(connector
, DCB_OUTPUT_ANALOG
))))
483 for_each_child_of_node(dn
, cn
) {
484 const char *name
= of_get_property(cn
, "name", NULL
);
485 const void *edid
= of_get_property(cn
, "EDID", NULL
);
486 int idx
= name
? name
[strlen(name
) - 1] - 'A' : 0;
488 if (nv_encoder
->dcb
->i2c_index
== idx
&& edid
) {
490 kmemdup(edid
, EDID_LENGTH
, GFP_KERNEL
);
500 nouveau_connector_set_encoder(struct drm_connector
*connector
,
501 struct nouveau_encoder
*nv_encoder
)
503 struct nouveau_connector
*nv_connector
= nouveau_connector(connector
);
504 struct nouveau_drm
*drm
= nouveau_drm(connector
->dev
);
505 struct drm_device
*dev
= connector
->dev
;
507 if (nv_connector
->detected_encoder
== nv_encoder
)
509 nv_connector
->detected_encoder
= nv_encoder
;
511 if (drm
->client
.device
.info
.family
>= NV_DEVICE_INFO_V0_TESLA
) {
512 if (nv_encoder
->dcb
->type
== DCB_OUTPUT_DP
)
513 connector
->interlace_allowed
=
514 nv_encoder
->caps
.dp_interlace
;
516 connector
->interlace_allowed
= true;
517 connector
->doublescan_allowed
= true;
519 if (nv_encoder
->dcb
->type
== DCB_OUTPUT_LVDS
||
520 nv_encoder
->dcb
->type
== DCB_OUTPUT_TMDS
) {
521 connector
->doublescan_allowed
= false;
522 connector
->interlace_allowed
= false;
524 connector
->doublescan_allowed
= true;
525 if (drm
->client
.device
.info
.family
== NV_DEVICE_INFO_V0_KELVIN
||
526 (drm
->client
.device
.info
.family
== NV_DEVICE_INFO_V0_CELSIUS
&&
527 (dev
->pdev
->device
& 0x0ff0) != 0x0100 &&
528 (dev
->pdev
->device
& 0x0ff0) != 0x0150))
530 connector
->interlace_allowed
= false;
532 connector
->interlace_allowed
= true;
535 if (nv_connector
->type
== DCB_CONNECTOR_DVI_I
) {
536 drm_object_property_set_value(&connector
->base
,
537 dev
->mode_config
.dvi_i_subconnector_property
,
538 nv_encoder
->dcb
->type
== DCB_OUTPUT_TMDS
?
539 DRM_MODE_SUBCONNECTOR_DVID
:
540 DRM_MODE_SUBCONNECTOR_DVIA
);
544 static enum drm_connector_status
545 nouveau_connector_detect(struct drm_connector
*connector
, bool force
)
547 struct drm_device
*dev
= connector
->dev
;
548 struct nouveau_drm
*drm
= nouveau_drm(dev
);
549 struct nouveau_connector
*nv_connector
= nouveau_connector(connector
);
550 struct nouveau_encoder
*nv_encoder
= NULL
;
551 struct nouveau_encoder
*nv_partner
;
552 struct i2c_adapter
*i2c
;
555 enum drm_connector_status conn_status
= connector_status_disconnected
;
557 /* Cleanup the previous EDID block. */
558 if (nv_connector
->edid
) {
559 drm_connector_update_edid_property(connector
, NULL
);
560 kfree(nv_connector
->edid
);
561 nv_connector
->edid
= NULL
;
564 /* Outputs are only polled while runtime active, so resuming the
565 * device here is unnecessary (and would deadlock upon runtime suspend
566 * because it waits for polling to finish). We do however, want to
567 * prevent the autosuspend timer from elapsing during this operation
570 if (drm_kms_helper_is_poll_worker()) {
571 pm_runtime_get_noresume(dev
->dev
);
573 ret
= pm_runtime_get_sync(dev
->dev
);
574 if (ret
< 0 && ret
!= -EACCES
)
578 nv_encoder
= nouveau_connector_ddc_detect(connector
);
579 if (nv_encoder
&& (i2c
= nv_encoder
->i2c
) != NULL
) {
580 if ((vga_switcheroo_handler_flags() &
581 VGA_SWITCHEROO_CAN_SWITCH_DDC
) &&
582 nv_connector
->type
== DCB_CONNECTOR_LVDS
)
583 nv_connector
->edid
= drm_get_edid_switcheroo(connector
,
586 nv_connector
->edid
= drm_get_edid(connector
, i2c
);
588 drm_connector_update_edid_property(connector
,
590 if (!nv_connector
->edid
) {
591 NV_ERROR(drm
, "DDC responded, but no EDID for %s\n",
596 /* Override encoder type for DVI-I based on whether EDID
597 * says the display is digital or analog, both use the
598 * same i2c channel so the value returned from ddc_detect
599 * isn't necessarily correct.
602 if (nv_encoder
->dcb
->type
== DCB_OUTPUT_TMDS
)
603 nv_partner
= find_encoder(connector
, DCB_OUTPUT_ANALOG
);
604 if (nv_encoder
->dcb
->type
== DCB_OUTPUT_ANALOG
)
605 nv_partner
= find_encoder(connector
, DCB_OUTPUT_TMDS
);
607 if (nv_partner
&& ((nv_encoder
->dcb
->type
== DCB_OUTPUT_ANALOG
&&
608 nv_partner
->dcb
->type
== DCB_OUTPUT_TMDS
) ||
609 (nv_encoder
->dcb
->type
== DCB_OUTPUT_TMDS
&&
610 nv_partner
->dcb
->type
== DCB_OUTPUT_ANALOG
))) {
611 if (nv_connector
->edid
->input
& DRM_EDID_INPUT_DIGITAL
)
612 type
= DCB_OUTPUT_TMDS
;
614 type
= DCB_OUTPUT_ANALOG
;
616 nv_encoder
= find_encoder(connector
, type
);
619 nouveau_connector_set_encoder(connector
, nv_encoder
);
620 conn_status
= connector_status_connected
;
621 drm_dp_cec_set_edid(&nv_connector
->aux
, nv_connector
->edid
);
625 nv_encoder
= nouveau_connector_of_detect(connector
);
627 nouveau_connector_set_encoder(connector
, nv_encoder
);
628 conn_status
= connector_status_connected
;
633 nv_encoder
= find_encoder(connector
, DCB_OUTPUT_ANALOG
);
634 if (!nv_encoder
&& !nouveau_tv_disable
)
635 nv_encoder
= find_encoder(connector
, DCB_OUTPUT_TV
);
636 if (nv_encoder
&& force
) {
637 struct drm_encoder
*encoder
= to_drm_encoder(nv_encoder
);
638 const struct drm_encoder_helper_funcs
*helper
=
639 encoder
->helper_private
;
641 if (helper
->detect(encoder
, connector
) ==
642 connector_status_connected
) {
643 nouveau_connector_set_encoder(connector
, nv_encoder
);
644 conn_status
= connector_status_connected
;
652 pm_runtime_mark_last_busy(dev
->dev
);
653 pm_runtime_put_autosuspend(dev
->dev
);
658 static enum drm_connector_status
659 nouveau_connector_detect_lvds(struct drm_connector
*connector
, bool force
)
661 struct drm_device
*dev
= connector
->dev
;
662 struct nouveau_drm
*drm
= nouveau_drm(dev
);
663 struct nouveau_connector
*nv_connector
= nouveau_connector(connector
);
664 struct nouveau_encoder
*nv_encoder
= NULL
;
665 enum drm_connector_status status
= connector_status_disconnected
;
667 /* Cleanup the previous EDID block. */
668 if (nv_connector
->edid
) {
669 drm_connector_update_edid_property(connector
, NULL
);
670 kfree(nv_connector
->edid
);
671 nv_connector
->edid
= NULL
;
674 nv_encoder
= find_encoder(connector
, DCB_OUTPUT_LVDS
);
676 return connector_status_disconnected
;
678 /* Try retrieving EDID via DDC */
679 if (!drm
->vbios
.fp_no_ddc
) {
680 status
= nouveau_connector_detect(connector
, force
);
681 if (status
== connector_status_connected
)
685 /* On some laptops (Sony, i'm looking at you) there appears to
686 * be no direct way of accessing the panel's EDID. The only
687 * option available to us appears to be to ask ACPI for help..
689 * It's important this check's before trying straps, one of the
690 * said manufacturer's laptops are configured in such a way
691 * the nouveau decides an entry in the VBIOS FP mode table is
692 * valid - it's not (rh#613284)
694 if (nv_encoder
->dcb
->lvdsconf
.use_acpi_for_edid
) {
695 if ((nv_connector
->edid
= nouveau_acpi_edid(dev
, connector
))) {
696 status
= connector_status_connected
;
701 /* If no EDID found above, and the VBIOS indicates a hardcoded
702 * modeline is avalilable for the panel, set it as the panel's
703 * native mode and exit.
705 if (nouveau_bios_fp_mode(dev
, NULL
) && (drm
->vbios
.fp_no_ddc
||
706 nv_encoder
->dcb
->lvdsconf
.use_straps_for_mode
)) {
707 status
= connector_status_connected
;
711 /* Still nothing, some VBIOS images have a hardcoded EDID block
712 * stored for the panel stored in them.
714 if (!drm
->vbios
.fp_no_ddc
) {
716 (struct edid
*)nouveau_bios_embedded_edid(dev
);
719 kmemdup(edid
, EDID_LENGTH
, GFP_KERNEL
);
720 if (nv_connector
->edid
)
721 status
= connector_status_connected
;
726 #if defined(CONFIG_ACPI_BUTTON) || \
727 (defined(CONFIG_ACPI_BUTTON_MODULE) && defined(MODULE))
728 if (status
== connector_status_connected
&&
729 !nouveau_ignorelid
&& !acpi_lid_open())
730 status
= connector_status_unknown
;
733 drm_connector_update_edid_property(connector
, nv_connector
->edid
);
734 nouveau_connector_set_encoder(connector
, nv_encoder
);
739 nouveau_connector_force(struct drm_connector
*connector
)
741 struct nouveau_drm
*drm
= nouveau_drm(connector
->dev
);
742 struct nouveau_connector
*nv_connector
= nouveau_connector(connector
);
743 struct nouveau_encoder
*nv_encoder
;
746 if (nv_connector
->type
== DCB_CONNECTOR_DVI_I
) {
747 if (connector
->force
== DRM_FORCE_ON_DIGITAL
)
748 type
= DCB_OUTPUT_TMDS
;
750 type
= DCB_OUTPUT_ANALOG
;
752 type
= DCB_OUTPUT_ANY
;
754 nv_encoder
= find_encoder(connector
, type
);
756 NV_ERROR(drm
, "can't find encoder to force %s on!\n",
758 connector
->status
= connector_status_disconnected
;
762 nouveau_connector_set_encoder(connector
, nv_encoder
);
766 nouveau_connector_set_property(struct drm_connector
*connector
,
767 struct drm_property
*property
, uint64_t value
)
769 struct nouveau_connector
*nv_connector
= nouveau_connector(connector
);
770 struct nouveau_encoder
*nv_encoder
= nv_connector
->detected_encoder
;
771 struct nouveau_conn_atom
*asyc
= &nv_connector
->properties_state
;
772 struct drm_encoder
*encoder
= to_drm_encoder(nv_encoder
);
775 ret
= connector
->funcs
->atomic_set_property(&nv_connector
->base
,
779 if (nv_encoder
&& nv_encoder
->dcb
->type
== DCB_OUTPUT_TV
)
780 return get_slave_funcs(encoder
)->set_property(
781 encoder
, connector
, property
, value
);
785 nv_connector
->scaling_mode
= asyc
->scaler
.mode
;
786 nv_connector
->dithering_mode
= asyc
->dither
.mode
;
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
,
806 static struct moderec scaler_modes
[] = {
825 nouveau_connector_scaler_modes_add(struct drm_connector
*connector
)
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];
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,
847 drm_mode_probed_add(connector
, m
);
858 nouveau_connector_detect_depth(struct drm_connector
*connector
)
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
;
867 /* if the edid is feeling nice enough to provide this info, use it */
868 if (nv_connector
->edid
&& connector
->display_info
.bpc
)
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;
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;
883 connector
->display_info
.bpc
= 6;
885 /* LVDS: panel straps */
886 if (bios
->fp_no_ddc
) {
887 if (bios
->fp
.if_is_24bit
)
888 connector
->display_info
.bpc
= 8;
892 /* LVDS: DDC panel, need to first determine the number of links to
893 * know which if_is_24bit flag to check...
895 if (nv_connector
->edid
&&
896 nv_connector
->type
== DCB_CONNECTOR_LVDS_SPWG
)
897 duallink
= ((u8
*)nv_connector
->edid
)[121] == 2;
899 duallink
= mode
->clock
>= bios
->fp
.duallink_transition_clk
;
901 if ((!duallink
&& (bios
->fp
.strapless_is_24bit
& 1)) ||
902 ( duallink
&& (bios
->fp
.strapless_is_24bit
& 2)))
903 connector
->display_info
.bpc
= 8;
907 nouveau_connector_late_register(struct drm_connector
*connector
)
911 ret
= nouveau_backlight_init(connector
);
917 nouveau_connector_early_unregister(struct drm_connector
*connector
)
919 nouveau_backlight_fini(connector
);
923 nouveau_connector_get_modes(struct drm_connector
*connector
)
925 struct drm_device
*dev
= connector
->dev
;
926 struct nouveau_drm
*drm
= nouveau_drm(dev
);
927 struct nouveau_connector
*nv_connector
= nouveau_connector(connector
);
928 struct nouveau_encoder
*nv_encoder
= nv_connector
->detected_encoder
;
929 struct drm_encoder
*encoder
= to_drm_encoder(nv_encoder
);
932 /* destroy the native mode, the attached monitor could have changed.
934 if (nv_connector
->native_mode
) {
935 drm_mode_destroy(dev
, nv_connector
->native_mode
);
936 nv_connector
->native_mode
= NULL
;
939 if (nv_connector
->edid
)
940 ret
= drm_add_edid_modes(connector
, nv_connector
->edid
);
942 if (nv_encoder
->dcb
->type
== DCB_OUTPUT_LVDS
&&
943 (nv_encoder
->dcb
->lvdsconf
.use_straps_for_mode
||
944 drm
->vbios
.fp_no_ddc
) && nouveau_bios_fp_mode(dev
, NULL
)) {
945 struct drm_display_mode mode
;
947 nouveau_bios_fp_mode(dev
, &mode
);
948 nv_connector
->native_mode
= drm_mode_duplicate(dev
, &mode
);
951 /* Determine display colour depth for everything except LVDS now,
952 * DP requires this before mode_valid() is called.
954 if (connector
->connector_type
!= DRM_MODE_CONNECTOR_LVDS
)
955 nouveau_connector_detect_depth(connector
);
957 /* Find the native mode if this is a digital panel, if we didn't
958 * find any modes through DDC previously add the native mode to
961 if (!nv_connector
->native_mode
)
962 nv_connector
->native_mode
= nouveau_conn_native_mode(connector
);
963 if (ret
== 0 && nv_connector
->native_mode
) {
964 struct drm_display_mode
*mode
;
966 mode
= drm_mode_duplicate(dev
, nv_connector
->native_mode
);
967 drm_mode_probed_add(connector
, mode
);
971 /* Determine LVDS colour depth, must happen after determining
972 * "native" mode as some VBIOS tables require us to use the
973 * pixel clock as part of the lookup...
975 if (connector
->connector_type
== DRM_MODE_CONNECTOR_LVDS
)
976 nouveau_connector_detect_depth(connector
);
978 if (nv_encoder
->dcb
->type
== DCB_OUTPUT_TV
)
979 ret
= get_slave_funcs(encoder
)->get_modes(encoder
, connector
);
981 if (nv_connector
->type
== DCB_CONNECTOR_LVDS
||
982 nv_connector
->type
== DCB_CONNECTOR_LVDS_SPWG
||
983 nv_connector
->type
== DCB_CONNECTOR_eDP
)
984 ret
+= nouveau_connector_scaler_modes_add(connector
);
990 get_tmds_link_bandwidth(struct drm_connector
*connector
)
992 struct nouveau_connector
*nv_connector
= nouveau_connector(connector
);
993 struct nouveau_encoder
*nv_encoder
= nv_connector
->detected_encoder
;
994 struct nouveau_drm
*drm
= nouveau_drm(connector
->dev
);
995 struct dcb_output
*dcb
= nv_connector
->detected_encoder
->dcb
;
996 struct drm_display_info
*info
= NULL
;
997 unsigned duallink_scale
=
998 nouveau_duallink
&& nv_encoder
->dcb
->duallink_possible
? 2 : 1;
1000 if (drm_detect_hdmi_monitor(nv_connector
->edid
)) {
1001 info
= &nv_connector
->base
.display_info
;
1006 if (nouveau_hdmimhz
> 0)
1007 return nouveau_hdmimhz
* 1000;
1008 /* Note: these limits are conservative, some Fermi's
1009 * can do 297 MHz. Unclear how this can be determined.
1011 if (drm
->client
.device
.info
.chipset
>= 0x120) {
1012 const int max_tmds_clock
=
1013 info
->hdmi
.scdc
.scrambling
.supported
?
1015 return info
->max_tmds_clock
?
1016 min(info
->max_tmds_clock
, max_tmds_clock
) :
1019 if (drm
->client
.device
.info
.family
>= NV_DEVICE_INFO_V0_KEPLER
)
1021 if (drm
->client
.device
.info
.family
>= NV_DEVICE_INFO_V0_FERMI
)
1025 if (dcb
->location
!= DCB_LOC_ON_CHIP
||
1026 drm
->client
.device
.info
.chipset
>= 0x46)
1027 return 165000 * duallink_scale
;
1028 else if (drm
->client
.device
.info
.chipset
>= 0x40)
1029 return 155000 * duallink_scale
;
1030 else if (drm
->client
.device
.info
.chipset
>= 0x18)
1031 return 135000 * duallink_scale
;
1033 return 112000 * duallink_scale
;
1036 enum drm_mode_status
1037 nouveau_conn_mode_clock_valid(const struct drm_display_mode
*mode
,
1038 const unsigned min_clock
,
1039 const unsigned max_clock
,
1040 unsigned int *clock_out
)
1042 unsigned int clock
= mode
->clock
;
1044 if ((mode
->flags
& DRM_MODE_FLAG_3D_MASK
) ==
1045 DRM_MODE_FLAG_3D_FRAME_PACKING
)
1048 if (clock
< min_clock
)
1049 return MODE_CLOCK_LOW
;
1050 if (clock
> max_clock
)
1051 return MODE_CLOCK_HIGH
;
1059 static enum drm_mode_status
1060 nouveau_connector_mode_valid(struct drm_connector
*connector
,
1061 struct drm_display_mode
*mode
)
1063 struct nouveau_connector
*nv_connector
= nouveau_connector(connector
);
1064 struct nouveau_encoder
*nv_encoder
= nv_connector
->detected_encoder
;
1065 struct drm_encoder
*encoder
= to_drm_encoder(nv_encoder
);
1066 unsigned min_clock
= 25000, max_clock
= min_clock
;
1068 switch (nv_encoder
->dcb
->type
) {
1069 case DCB_OUTPUT_LVDS
:
1070 if (nv_connector
->native_mode
&&
1071 (mode
->hdisplay
> nv_connector
->native_mode
->hdisplay
||
1072 mode
->vdisplay
> nv_connector
->native_mode
->vdisplay
))
1078 case DCB_OUTPUT_TMDS
:
1079 max_clock
= get_tmds_link_bandwidth(connector
);
1081 case DCB_OUTPUT_ANALOG
:
1082 max_clock
= nv_encoder
->dcb
->crtconf
.maxfreq
;
1087 return get_slave_funcs(encoder
)->mode_valid(encoder
, mode
);
1089 return nv50_dp_mode_valid(connector
, nv_encoder
, mode
, NULL
);
1095 return nouveau_conn_mode_clock_valid(mode
, min_clock
, max_clock
,
1099 static struct drm_encoder
*
1100 nouveau_connector_best_encoder(struct drm_connector
*connector
)
1102 struct nouveau_connector
*nv_connector
= nouveau_connector(connector
);
1104 if (nv_connector
->detected_encoder
)
1105 return to_drm_encoder(nv_connector
->detected_encoder
);
1110 static const struct drm_connector_helper_funcs
1111 nouveau_connector_helper_funcs
= {
1112 .get_modes
= nouveau_connector_get_modes
,
1113 .mode_valid
= nouveau_connector_mode_valid
,
1114 .best_encoder
= nouveau_connector_best_encoder
,
1117 static const struct drm_connector_funcs
1118 nouveau_connector_funcs
= {
1119 .dpms
= drm_helper_connector_dpms
,
1120 .reset
= nouveau_conn_reset
,
1121 .detect
= nouveau_connector_detect
,
1122 .force
= nouveau_connector_force
,
1123 .fill_modes
= drm_helper_probe_single_connector_modes
,
1124 .set_property
= nouveau_connector_set_property
,
1125 .destroy
= nouveau_connector_destroy
,
1126 .atomic_duplicate_state
= nouveau_conn_atomic_duplicate_state
,
1127 .atomic_destroy_state
= nouveau_conn_atomic_destroy_state
,
1128 .atomic_set_property
= nouveau_conn_atomic_set_property
,
1129 .atomic_get_property
= nouveau_conn_atomic_get_property
,
1130 .late_register
= nouveau_connector_late_register
,
1131 .early_unregister
= nouveau_connector_early_unregister
,
1134 static const struct drm_connector_funcs
1135 nouveau_connector_funcs_lvds
= {
1136 .dpms
= drm_helper_connector_dpms
,
1137 .reset
= nouveau_conn_reset
,
1138 .detect
= nouveau_connector_detect_lvds
,
1139 .force
= nouveau_connector_force
,
1140 .fill_modes
= drm_helper_probe_single_connector_modes
,
1141 .set_property
= nouveau_connector_set_property
,
1142 .destroy
= nouveau_connector_destroy
,
1143 .atomic_duplicate_state
= nouveau_conn_atomic_duplicate_state
,
1144 .atomic_destroy_state
= nouveau_conn_atomic_destroy_state
,
1145 .atomic_set_property
= nouveau_conn_atomic_set_property
,
1146 .atomic_get_property
= nouveau_conn_atomic_get_property
,
1147 .late_register
= nouveau_connector_late_register
,
1148 .early_unregister
= nouveau_connector_early_unregister
,
1152 nouveau_connector_hotplug(struct nvif_notify
*notify
)
1154 struct nouveau_connector
*nv_connector
=
1155 container_of(notify
, typeof(*nv_connector
), hpd
);
1156 struct drm_connector
*connector
= &nv_connector
->base
;
1157 struct nouveau_drm
*drm
= nouveau_drm(connector
->dev
);
1158 const struct nvif_notify_conn_rep_v0
*rep
= notify
->data
;
1159 const char *name
= connector
->name
;
1160 struct nouveau_encoder
*nv_encoder
;
1162 bool plugged
= (rep
->mask
!= NVIF_NOTIFY_CONN_V0_UNPLUG
);
1164 if (rep
->mask
& NVIF_NOTIFY_CONN_V0_IRQ
) {
1165 NV_DEBUG(drm
, "service %s\n", name
);
1166 drm_dp_cec_irq(&nv_connector
->aux
);
1167 if ((nv_encoder
= find_encoder(connector
, DCB_OUTPUT_DP
)))
1168 nv50_mstm_service(nv_encoder
->dp
.mstm
);
1170 return NVIF_NOTIFY_KEEP
;
1173 ret
= pm_runtime_get(drm
->dev
->dev
);
1175 /* We can't block here if there's a pending PM request
1176 * running, as we'll deadlock nouveau_display_fini() when it
1177 * calls nvif_put() on our nvif_notify struct. So, simply
1178 * defer the hotplug event until the device finishes resuming
1180 NV_DEBUG(drm
, "Deferring HPD on %s until runtime resume\n",
1182 schedule_work(&drm
->hpd_work
);
1184 pm_runtime_put_noidle(drm
->dev
->dev
);
1185 return NVIF_NOTIFY_KEEP
;
1186 } else if (ret
!= 1 && ret
!= -EACCES
) {
1187 NV_WARN(drm
, "HPD on %s dropped due to RPM failure: %d\n",
1189 return NVIF_NOTIFY_DROP
;
1193 drm_dp_cec_unset_edid(&nv_connector
->aux
);
1194 NV_DEBUG(drm
, "%splugged %s\n", plugged
? "" : "un", name
);
1195 if ((nv_encoder
= find_encoder(connector
, DCB_OUTPUT_DP
))) {
1197 nv50_mstm_remove(nv_encoder
->dp
.mstm
);
1200 drm_helper_hpd_irq_event(connector
->dev
);
1202 pm_runtime_mark_last_busy(drm
->dev
->dev
);
1203 pm_runtime_put_autosuspend(drm
->dev
->dev
);
1204 return NVIF_NOTIFY_KEEP
;
1208 nouveau_connector_aux_xfer(struct drm_dp_aux
*obj
, struct drm_dp_aux_msg
*msg
)
1210 struct nouveau_connector
*nv_connector
=
1211 container_of(obj
, typeof(*nv_connector
), aux
);
1212 struct nouveau_encoder
*nv_encoder
;
1213 struct nvkm_i2c_aux
*aux
;
1214 u8 size
= msg
->size
;
1217 nv_encoder
= find_encoder(&nv_connector
->base
, DCB_OUTPUT_DP
);
1218 if (!nv_encoder
|| !(aux
= nv_encoder
->aux
))
1220 if (WARN_ON(msg
->size
> 16))
1223 ret
= nvkm_i2c_aux_acquire(aux
);
1227 ret
= nvkm_i2c_aux_xfer(aux
, false, msg
->request
, msg
->address
,
1228 msg
->buffer
, &size
);
1229 nvkm_i2c_aux_release(aux
);
1239 drm_conntype_from_dcb(enum dcb_connector_type dcb
)
1242 case DCB_CONNECTOR_VGA
: return DRM_MODE_CONNECTOR_VGA
;
1243 case DCB_CONNECTOR_TV_0
:
1244 case DCB_CONNECTOR_TV_1
:
1245 case DCB_CONNECTOR_TV_3
: return DRM_MODE_CONNECTOR_TV
;
1246 case DCB_CONNECTOR_DMS59_0
:
1247 case DCB_CONNECTOR_DMS59_1
:
1248 case DCB_CONNECTOR_DVI_I
: return DRM_MODE_CONNECTOR_DVII
;
1249 case DCB_CONNECTOR_DVI_D
: return DRM_MODE_CONNECTOR_DVID
;
1250 case DCB_CONNECTOR_LVDS
:
1251 case DCB_CONNECTOR_LVDS_SPWG
: return DRM_MODE_CONNECTOR_LVDS
;
1252 case DCB_CONNECTOR_DMS59_DP0
:
1253 case DCB_CONNECTOR_DMS59_DP1
:
1254 case DCB_CONNECTOR_DP
:
1255 case DCB_CONNECTOR_USB_C
: return DRM_MODE_CONNECTOR_DisplayPort
;
1256 case DCB_CONNECTOR_eDP
: return DRM_MODE_CONNECTOR_eDP
;
1257 case DCB_CONNECTOR_HDMI_0
:
1258 case DCB_CONNECTOR_HDMI_1
:
1259 case DCB_CONNECTOR_HDMI_C
: return DRM_MODE_CONNECTOR_HDMIA
;
1260 case DCB_CONNECTOR_WFD
: return DRM_MODE_CONNECTOR_VIRTUAL
;
1265 return DRM_MODE_CONNECTOR_Unknown
;
1268 struct drm_connector
*
1269 nouveau_connector_create(struct drm_device
*dev
,
1270 const struct dcb_output
*dcbe
)
1272 const struct drm_connector_funcs
*funcs
= &nouveau_connector_funcs
;
1273 struct nouveau_drm
*drm
= nouveau_drm(dev
);
1274 struct nouveau_display
*disp
= nouveau_display(dev
);
1275 struct nouveau_connector
*nv_connector
= NULL
;
1276 struct drm_connector
*connector
;
1277 struct drm_connector_list_iter conn_iter
;
1278 char aux_name
[48] = {0};
1279 int index
= dcbe
->connector
;
1283 drm_connector_list_iter_begin(dev
, &conn_iter
);
1284 nouveau_for_each_non_mst_connector_iter(connector
, &conn_iter
) {
1285 nv_connector
= nouveau_connector(connector
);
1286 if (nv_connector
->index
== index
) {
1287 drm_connector_list_iter_end(&conn_iter
);
1291 drm_connector_list_iter_end(&conn_iter
);
1293 nv_connector
= kzalloc(sizeof(*nv_connector
), GFP_KERNEL
);
1295 return ERR_PTR(-ENOMEM
);
1297 connector
= &nv_connector
->base
;
1298 nv_connector
->index
= index
;
1300 /* attempt to parse vbios connector type and hotplug gpio */
1301 nv_connector
->dcb
= olddcb_conn(dev
, index
);
1302 if (nv_connector
->dcb
) {
1303 u32 entry
= ROM16(nv_connector
->dcb
[0]);
1304 if (olddcb_conntab(dev
)[3] >= 4)
1305 entry
|= (u32
)ROM16(nv_connector
->dcb
[2]) << 16;
1307 nv_connector
->type
= nv_connector
->dcb
[0];
1308 if (drm_conntype_from_dcb(nv_connector
->type
) ==
1309 DRM_MODE_CONNECTOR_Unknown
) {
1310 NV_WARN(drm
, "unknown connector type %02x\n",
1311 nv_connector
->type
);
1312 nv_connector
->type
= DCB_CONNECTOR_NONE
;
1315 /* Gigabyte NX85T */
1316 if (nv_match_device(dev
, 0x0421, 0x1458, 0x344c)) {
1317 if (nv_connector
->type
== DCB_CONNECTOR_HDMI_1
)
1318 nv_connector
->type
= DCB_CONNECTOR_DVI_I
;
1321 /* Gigabyte GV-NX86T512H */
1322 if (nv_match_device(dev
, 0x0402, 0x1458, 0x3455)) {
1323 if (nv_connector
->type
== DCB_CONNECTOR_HDMI_1
)
1324 nv_connector
->type
= DCB_CONNECTOR_DVI_I
;
1327 nv_connector
->type
= DCB_CONNECTOR_NONE
;
1330 /* no vbios data, or an unknown dcb connector type - attempt to
1331 * figure out something suitable ourselves
1333 if (nv_connector
->type
== DCB_CONNECTOR_NONE
) {
1334 struct nouveau_drm
*drm
= nouveau_drm(dev
);
1335 struct dcb_table
*dcbt
= &drm
->vbios
.dcb
;
1339 for (i
= 0; i
< dcbt
->entries
; i
++) {
1340 if (dcbt
->entry
[i
].connector
== nv_connector
->index
)
1341 encoders
|= (1 << dcbt
->entry
[i
].type
);
1344 if (encoders
& (1 << DCB_OUTPUT_DP
)) {
1345 if (encoders
& (1 << DCB_OUTPUT_TMDS
))
1346 nv_connector
->type
= DCB_CONNECTOR_DP
;
1348 nv_connector
->type
= DCB_CONNECTOR_eDP
;
1350 if (encoders
& (1 << DCB_OUTPUT_TMDS
)) {
1351 if (encoders
& (1 << DCB_OUTPUT_ANALOG
))
1352 nv_connector
->type
= DCB_CONNECTOR_DVI_I
;
1354 nv_connector
->type
= DCB_CONNECTOR_DVI_D
;
1356 if (encoders
& (1 << DCB_OUTPUT_ANALOG
)) {
1357 nv_connector
->type
= DCB_CONNECTOR_VGA
;
1359 if (encoders
& (1 << DCB_OUTPUT_LVDS
)) {
1360 nv_connector
->type
= DCB_CONNECTOR_LVDS
;
1362 if (encoders
& (1 << DCB_OUTPUT_TV
)) {
1363 nv_connector
->type
= DCB_CONNECTOR_TV_0
;
1367 switch ((type
= drm_conntype_from_dcb(nv_connector
->type
))) {
1368 case DRM_MODE_CONNECTOR_LVDS
:
1369 ret
= nouveau_bios_parse_lvds_table(dev
, 0, &dummy
, &dummy
);
1371 NV_ERROR(drm
, "Error parsing LVDS table, disabling\n");
1372 kfree(nv_connector
);
1373 return ERR_PTR(ret
);
1376 funcs
= &nouveau_connector_funcs_lvds
;
1378 case DRM_MODE_CONNECTOR_DisplayPort
:
1379 case DRM_MODE_CONNECTOR_eDP
:
1380 nv_connector
->aux
.dev
= connector
->kdev
;
1381 nv_connector
->aux
.transfer
= nouveau_connector_aux_xfer
;
1382 snprintf(aux_name
, sizeof(aux_name
), "sor-%04x-%04x",
1383 dcbe
->hasht
, dcbe
->hashm
);
1384 nv_connector
->aux
.name
= kstrdup(aux_name
, GFP_KERNEL
);
1385 ret
= drm_dp_aux_register(&nv_connector
->aux
);
1387 NV_ERROR(drm
, "failed to register aux channel\n");
1388 kfree(nv_connector
);
1389 return ERR_PTR(ret
);
1391 funcs
= &nouveau_connector_funcs
;
1394 funcs
= &nouveau_connector_funcs
;
1398 /* HDMI 3D support */
1399 if ((disp
->disp
.object
.oclass
>= G82_DISP
)
1400 && ((type
== DRM_MODE_CONNECTOR_DisplayPort
)
1401 || (type
== DRM_MODE_CONNECTOR_eDP
)
1402 || (type
== DRM_MODE_CONNECTOR_HDMIA
)))
1403 connector
->stereo_allowed
= true;
1405 /* defaults, will get overridden in detect() */
1406 connector
->interlace_allowed
= false;
1407 connector
->doublescan_allowed
= false;
1409 drm_connector_init(dev
, connector
, funcs
, type
);
1410 drm_connector_helper_add(connector
, &nouveau_connector_helper_funcs
);
1412 connector
->funcs
->reset(connector
);
1413 nouveau_conn_attach_properties(connector
);
1415 /* Default scaling mode */
1416 switch (nv_connector
->type
) {
1417 case DCB_CONNECTOR_LVDS
:
1418 case DCB_CONNECTOR_LVDS_SPWG
:
1419 case DCB_CONNECTOR_eDP
:
1420 /* see note in nouveau_connector_set_property() */
1421 if (disp
->disp
.object
.oclass
< NV50_DISP
) {
1422 nv_connector
->scaling_mode
= DRM_MODE_SCALE_FULLSCREEN
;
1425 nv_connector
->scaling_mode
= DRM_MODE_SCALE_NONE
;
1428 nv_connector
->scaling_mode
= DRM_MODE_SCALE_NONE
;
1432 /* dithering properties */
1433 switch (nv_connector
->type
) {
1434 case DCB_CONNECTOR_TV_0
:
1435 case DCB_CONNECTOR_TV_1
:
1436 case DCB_CONNECTOR_TV_3
:
1437 case DCB_CONNECTOR_VGA
:
1440 nv_connector
->dithering_mode
= DITHERING_MODE_AUTO
;
1445 case DRM_MODE_CONNECTOR_DisplayPort
:
1446 case DRM_MODE_CONNECTOR_eDP
:
1447 drm_dp_cec_register_connector(&nv_connector
->aux
, connector
);
1451 ret
= nvif_notify_init(&disp
->disp
.object
, nouveau_connector_hotplug
,
1452 true, NV04_DISP_NTFY_CONN
,
1453 &(struct nvif_notify_conn_req_v0
) {
1454 .mask
= NVIF_NOTIFY_CONN_V0_ANY
,
1457 sizeof(struct nvif_notify_conn_req_v0
),
1458 sizeof(struct nvif_notify_conn_rep_v0
),
1459 &nv_connector
->hpd
);
1461 connector
->polled
= DRM_CONNECTOR_POLL_CONNECT
;
1463 connector
->polled
= DRM_CONNECTOR_POLL_HPD
;
1465 drm_connector_register(connector
);