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>
33 #include <drm/drm_atomic_helper.h>
34 #include <drm/drm_edid.h>
35 #include <drm/drm_crtc_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 "nouveau_acpi.h"
43 #include "nouveau_display.h"
44 #include "nouveau_connector.h"
45 #include "nouveau_encoder.h"
46 #include "nouveau_crtc.h"
48 #include <nvif/class.h>
49 #include <nvif/cl0046.h>
50 #include <nvif/event.h>
52 struct drm_display_mode
*
53 nouveau_conn_native_mode(struct drm_connector
*connector
)
55 const struct drm_connector_helper_funcs
*helper
= connector
->helper_private
;
56 struct nouveau_drm
*drm
= nouveau_drm(connector
->dev
);
57 struct drm_device
*dev
= connector
->dev
;
58 struct drm_display_mode
*mode
, *largest
= NULL
;
59 int high_w
= 0, high_h
= 0, high_v
= 0;
61 list_for_each_entry(mode
, &connector
->probed_modes
, head
) {
62 mode
->vrefresh
= drm_mode_vrefresh(mode
);
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 mode
->vrefresh
< high_v
)
86 high_w
= mode
->hdisplay
;
87 high_h
= mode
->vdisplay
;
88 high_v
= mode
->vrefresh
;
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
.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_conn_atom
*asyc
;
250 if (WARN_ON(!(asyc
= kzalloc(sizeof(*asyc
), GFP_KERNEL
))))
253 if (connector
->state
)
254 __drm_atomic_helper_connector_destroy_state(connector
->state
);
255 __drm_atomic_helper_connector_reset(connector
, &asyc
->state
);
256 asyc
->dither
.mode
= DITHERING_MODE_AUTO
;
257 asyc
->dither
.depth
= DITHERING_DEPTH_AUTO
;
258 asyc
->scaler
.mode
= DRM_MODE_SCALE_NONE
;
259 asyc
->scaler
.underscan
.mode
= UNDERSCAN_OFF
;
260 asyc
->procamp
.color_vibrance
= 150;
261 asyc
->procamp
.vibrant_hue
= 90;
263 if (nouveau_display(connector
->dev
)->disp
.oclass
< NV50_DISP
) {
264 switch (connector
->connector_type
) {
265 case DRM_MODE_CONNECTOR_LVDS
:
266 /* See note in nouveau_conn_atomic_set_property(). */
267 asyc
->scaler
.mode
= DRM_MODE_SCALE_FULLSCREEN
;
276 nouveau_conn_attach_properties(struct drm_connector
*connector
)
278 struct drm_device
*dev
= connector
->dev
;
279 struct nouveau_conn_atom
*armc
= nouveau_conn_atom(connector
->state
);
280 struct nouveau_display
*disp
= nouveau_display(dev
);
282 /* Init DVI-I specific properties. */
283 if (connector
->connector_type
== DRM_MODE_CONNECTOR_DVII
)
284 drm_object_attach_property(&connector
->base
, dev
->mode_config
.
285 dvi_i_subconnector_property
, 0);
287 /* Add overscan compensation options to digital outputs. */
288 if (disp
->underscan_property
&&
289 (connector
->connector_type
== DRM_MODE_CONNECTOR_DVID
||
290 connector
->connector_type
== DRM_MODE_CONNECTOR_DVII
||
291 connector
->connector_type
== DRM_MODE_CONNECTOR_HDMIA
||
292 connector
->connector_type
== DRM_MODE_CONNECTOR_DisplayPort
)) {
293 drm_object_attach_property(&connector
->base
,
294 disp
->underscan_property
,
296 drm_object_attach_property(&connector
->base
,
297 disp
->underscan_hborder_property
, 0);
298 drm_object_attach_property(&connector
->base
,
299 disp
->underscan_vborder_property
, 0);
302 /* Add hue and saturation options. */
303 if (disp
->vibrant_hue_property
)
304 drm_object_attach_property(&connector
->base
,
305 disp
->vibrant_hue_property
,
306 armc
->procamp
.vibrant_hue
);
307 if (disp
->color_vibrance_property
)
308 drm_object_attach_property(&connector
->base
,
309 disp
->color_vibrance_property
,
310 armc
->procamp
.color_vibrance
);
312 /* Scaling mode property. */
313 switch (connector
->connector_type
) {
314 case DRM_MODE_CONNECTOR_TV
:
316 case DRM_MODE_CONNECTOR_VGA
:
317 if (disp
->disp
.oclass
< NV50_DISP
)
318 break; /* Can only scale on DFPs. */
321 drm_object_attach_property(&connector
->base
, dev
->mode_config
.
322 scaling_mode_property
,
327 /* Dithering properties. */
328 switch (connector
->connector_type
) {
329 case DRM_MODE_CONNECTOR_TV
:
330 case DRM_MODE_CONNECTOR_VGA
:
333 if (disp
->dithering_mode
) {
334 drm_object_attach_property(&connector
->base
,
335 disp
->dithering_mode
,
338 if (disp
->dithering_depth
) {
339 drm_object_attach_property(&connector
->base
,
340 disp
->dithering_depth
,
347 MODULE_PARM_DESC(tv_disable
, "Disable TV-out detection");
348 int nouveau_tv_disable
= 0;
349 module_param_named(tv_disable
, nouveau_tv_disable
, int, 0400);
351 MODULE_PARM_DESC(ignorelid
, "Ignore ACPI lid status");
352 int nouveau_ignorelid
= 0;
353 module_param_named(ignorelid
, nouveau_ignorelid
, int, 0400);
355 MODULE_PARM_DESC(duallink
, "Allow dual-link TMDS (default: enabled)");
356 int nouveau_duallink
= 1;
357 module_param_named(duallink
, nouveau_duallink
, int, 0400);
359 MODULE_PARM_DESC(hdmimhz
, "Force a maximum HDMI pixel clock (in MHz)");
360 int nouveau_hdmimhz
= 0;
361 module_param_named(hdmimhz
, nouveau_hdmimhz
, int, 0400);
363 struct nouveau_encoder
*
364 find_encoder(struct drm_connector
*connector
, int type
)
366 struct drm_device
*dev
= connector
->dev
;
367 struct nouveau_encoder
*nv_encoder
;
368 struct drm_encoder
*enc
;
371 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
372 id
= connector
->encoder_ids
[i
];
376 enc
= drm_encoder_find(dev
, id
);
379 nv_encoder
= nouveau_encoder(enc
);
381 if (type
== DCB_OUTPUT_ANY
||
382 (nv_encoder
->dcb
&& nv_encoder
->dcb
->type
== type
))
389 struct nouveau_connector
*
390 nouveau_encoder_connector_get(struct nouveau_encoder
*encoder
)
392 struct drm_device
*dev
= to_drm_encoder(encoder
)->dev
;
393 struct drm_connector
*drm_connector
;
395 list_for_each_entry(drm_connector
, &dev
->mode_config
.connector_list
, head
) {
396 if (drm_connector
->encoder
== to_drm_encoder(encoder
))
397 return nouveau_connector(drm_connector
);
404 nouveau_connector_destroy(struct drm_connector
*connector
)
406 struct nouveau_connector
*nv_connector
= nouveau_connector(connector
);
407 nvif_notify_fini(&nv_connector
->hpd
);
408 kfree(nv_connector
->edid
);
409 drm_connector_unregister(connector
);
410 drm_connector_cleanup(connector
);
411 if (nv_connector
->aux
.transfer
)
412 drm_dp_aux_unregister(&nv_connector
->aux
);
416 static struct nouveau_encoder
*
417 nouveau_connector_ddc_detect(struct drm_connector
*connector
)
419 struct drm_device
*dev
= connector
->dev
;
420 struct nouveau_connector
*nv_connector
= nouveau_connector(connector
);
421 struct nouveau_drm
*drm
= nouveau_drm(dev
);
422 struct nvkm_gpio
*gpio
= nvxx_gpio(&drm
->client
.device
);
423 struct nouveau_encoder
*nv_encoder
;
424 struct drm_encoder
*encoder
;
425 int i
, panel
= -ENODEV
;
427 /* eDP panels need powering on by us (if the VBIOS doesn't default it
428 * to on) before doing any AUX channel transactions. LVDS panel power
429 * is handled by the SOR itself, and not required for LVDS DDC.
431 if (nv_connector
->type
== DCB_CONNECTOR_eDP
) {
432 panel
= nvkm_gpio_get(gpio
, 0, DCB_GPIO_PANEL_POWER
, 0xff);
434 nvkm_gpio_set(gpio
, 0, DCB_GPIO_PANEL_POWER
, 0xff, 1);
439 for (i
= 0; nv_encoder
= NULL
, i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
440 int id
= connector
->encoder_ids
[i
];
444 encoder
= drm_encoder_find(dev
, id
);
447 nv_encoder
= nouveau_encoder(encoder
);
449 if (nv_encoder
->dcb
->type
== DCB_OUTPUT_DP
) {
450 int ret
= nouveau_dp_detect(nv_encoder
);
451 if (ret
== NOUVEAU_DP_MST
)
453 if (ret
== NOUVEAU_DP_SST
)
456 if ((vga_switcheroo_handler_flags() &
457 VGA_SWITCHEROO_CAN_SWITCH_DDC
) &&
458 nv_encoder
->dcb
->type
== DCB_OUTPUT_LVDS
&&
461 vga_switcheroo_lock_ddc(dev
->pdev
);
462 ret
= nvkm_probe_i2c(nv_encoder
->i2c
, 0x50);
463 vga_switcheroo_unlock_ddc(dev
->pdev
);
467 if (nv_encoder
->i2c
) {
468 if (nvkm_probe_i2c(nv_encoder
->i2c
, 0x50))
473 /* eDP panel not detected, restore panel power GPIO to previous
474 * state to avoid confusing the SOR for other output types.
476 if (!nv_encoder
&& panel
== 0)
477 nvkm_gpio_set(gpio
, 0, DCB_GPIO_PANEL_POWER
, 0xff, panel
);
482 static struct nouveau_encoder
*
483 nouveau_connector_of_detect(struct drm_connector
*connector
)
486 struct drm_device
*dev
= connector
->dev
;
487 struct nouveau_connector
*nv_connector
= nouveau_connector(connector
);
488 struct nouveau_encoder
*nv_encoder
;
489 struct device_node
*cn
, *dn
= pci_device_to_OF_node(dev
->pdev
);
492 !((nv_encoder
= find_encoder(connector
, DCB_OUTPUT_TMDS
)) ||
493 (nv_encoder
= find_encoder(connector
, DCB_OUTPUT_ANALOG
))))
496 for_each_child_of_node(dn
, cn
) {
497 const char *name
= of_get_property(cn
, "name", NULL
);
498 const void *edid
= of_get_property(cn
, "EDID", NULL
);
499 int idx
= name
? name
[strlen(name
) - 1] - 'A' : 0;
501 if (nv_encoder
->dcb
->i2c_index
== idx
&& edid
) {
503 kmemdup(edid
, EDID_LENGTH
, GFP_KERNEL
);
513 nouveau_connector_set_encoder(struct drm_connector
*connector
,
514 struct nouveau_encoder
*nv_encoder
)
516 struct nouveau_connector
*nv_connector
= nouveau_connector(connector
);
517 struct nouveau_drm
*drm
= nouveau_drm(connector
->dev
);
518 struct drm_device
*dev
= connector
->dev
;
520 if (nv_connector
->detected_encoder
== nv_encoder
)
522 nv_connector
->detected_encoder
= nv_encoder
;
524 if (drm
->client
.device
.info
.family
>= NV_DEVICE_INFO_V0_TESLA
) {
525 connector
->interlace_allowed
= true;
526 connector
->doublescan_allowed
= true;
528 if (nv_encoder
->dcb
->type
== DCB_OUTPUT_LVDS
||
529 nv_encoder
->dcb
->type
== DCB_OUTPUT_TMDS
) {
530 connector
->doublescan_allowed
= false;
531 connector
->interlace_allowed
= false;
533 connector
->doublescan_allowed
= true;
534 if (drm
->client
.device
.info
.family
== NV_DEVICE_INFO_V0_KELVIN
||
535 (drm
->client
.device
.info
.family
== NV_DEVICE_INFO_V0_CELSIUS
&&
536 (dev
->pdev
->device
& 0x0ff0) != 0x0100 &&
537 (dev
->pdev
->device
& 0x0ff0) != 0x0150))
539 connector
->interlace_allowed
= false;
541 connector
->interlace_allowed
= true;
544 if (nv_connector
->type
== DCB_CONNECTOR_DVI_I
) {
545 drm_object_property_set_value(&connector
->base
,
546 dev
->mode_config
.dvi_i_subconnector_property
,
547 nv_encoder
->dcb
->type
== DCB_OUTPUT_TMDS
?
548 DRM_MODE_SUBCONNECTOR_DVID
:
549 DRM_MODE_SUBCONNECTOR_DVIA
);
553 static enum drm_connector_status
554 nouveau_connector_detect(struct drm_connector
*connector
, bool force
)
556 struct drm_device
*dev
= connector
->dev
;
557 struct nouveau_drm
*drm
= nouveau_drm(dev
);
558 struct nouveau_connector
*nv_connector
= nouveau_connector(connector
);
559 struct nouveau_encoder
*nv_encoder
= NULL
;
560 struct nouveau_encoder
*nv_partner
;
561 struct i2c_adapter
*i2c
;
564 enum drm_connector_status conn_status
= connector_status_disconnected
;
566 /* Cleanup the previous EDID block. */
567 if (nv_connector
->edid
) {
568 drm_mode_connector_update_edid_property(connector
, NULL
);
569 kfree(nv_connector
->edid
);
570 nv_connector
->edid
= NULL
;
573 ret
= pm_runtime_get_sync(connector
->dev
->dev
);
574 if (ret
< 0 && ret
!= -EACCES
)
577 nv_encoder
= nouveau_connector_ddc_detect(connector
);
578 if (nv_encoder
&& (i2c
= nv_encoder
->i2c
) != NULL
) {
579 if ((vga_switcheroo_handler_flags() &
580 VGA_SWITCHEROO_CAN_SWITCH_DDC
) &&
581 nv_connector
->type
== DCB_CONNECTOR_LVDS
)
582 nv_connector
->edid
= drm_get_edid_switcheroo(connector
,
585 nv_connector
->edid
= drm_get_edid(connector
, i2c
);
587 drm_mode_connector_update_edid_property(connector
,
589 if (!nv_connector
->edid
) {
590 NV_ERROR(drm
, "DDC responded, but no EDID for %s\n",
595 /* Override encoder type for DVI-I based on whether EDID
596 * says the display is digital or analog, both use the
597 * same i2c channel so the value returned from ddc_detect
598 * isn't necessarily correct.
601 if (nv_encoder
->dcb
->type
== DCB_OUTPUT_TMDS
)
602 nv_partner
= find_encoder(connector
, DCB_OUTPUT_ANALOG
);
603 if (nv_encoder
->dcb
->type
== DCB_OUTPUT_ANALOG
)
604 nv_partner
= find_encoder(connector
, DCB_OUTPUT_TMDS
);
606 if (nv_partner
&& ((nv_encoder
->dcb
->type
== DCB_OUTPUT_ANALOG
&&
607 nv_partner
->dcb
->type
== DCB_OUTPUT_TMDS
) ||
608 (nv_encoder
->dcb
->type
== DCB_OUTPUT_TMDS
&&
609 nv_partner
->dcb
->type
== DCB_OUTPUT_ANALOG
))) {
610 if (nv_connector
->edid
->input
& DRM_EDID_INPUT_DIGITAL
)
611 type
= DCB_OUTPUT_TMDS
;
613 type
= DCB_OUTPUT_ANALOG
;
615 nv_encoder
= find_encoder(connector
, type
);
618 nouveau_connector_set_encoder(connector
, nv_encoder
);
619 conn_status
= connector_status_connected
;
623 nv_encoder
= nouveau_connector_of_detect(connector
);
625 nouveau_connector_set_encoder(connector
, nv_encoder
);
626 conn_status
= connector_status_connected
;
631 nv_encoder
= find_encoder(connector
, DCB_OUTPUT_ANALOG
);
632 if (!nv_encoder
&& !nouveau_tv_disable
)
633 nv_encoder
= find_encoder(connector
, DCB_OUTPUT_TV
);
634 if (nv_encoder
&& force
) {
635 struct drm_encoder
*encoder
= to_drm_encoder(nv_encoder
);
636 const struct drm_encoder_helper_funcs
*helper
=
637 encoder
->helper_private
;
639 if (helper
->detect(encoder
, connector
) ==
640 connector_status_connected
) {
641 nouveau_connector_set_encoder(connector
, nv_encoder
);
642 conn_status
= connector_status_connected
;
650 pm_runtime_mark_last_busy(connector
->dev
->dev
);
651 pm_runtime_put_autosuspend(connector
->dev
->dev
);
656 static enum drm_connector_status
657 nouveau_connector_detect_lvds(struct drm_connector
*connector
, bool force
)
659 struct drm_device
*dev
= connector
->dev
;
660 struct nouveau_drm
*drm
= nouveau_drm(dev
);
661 struct nouveau_connector
*nv_connector
= nouveau_connector(connector
);
662 struct nouveau_encoder
*nv_encoder
= NULL
;
663 enum drm_connector_status status
= connector_status_disconnected
;
665 /* Cleanup the previous EDID block. */
666 if (nv_connector
->edid
) {
667 drm_mode_connector_update_edid_property(connector
, NULL
);
668 kfree(nv_connector
->edid
);
669 nv_connector
->edid
= NULL
;
672 nv_encoder
= find_encoder(connector
, DCB_OUTPUT_LVDS
);
674 return connector_status_disconnected
;
676 /* Try retrieving EDID via DDC */
677 if (!drm
->vbios
.fp_no_ddc
) {
678 status
= nouveau_connector_detect(connector
, force
);
679 if (status
== connector_status_connected
)
683 /* On some laptops (Sony, i'm looking at you) there appears to
684 * be no direct way of accessing the panel's EDID. The only
685 * option available to us appears to be to ask ACPI for help..
687 * It's important this check's before trying straps, one of the
688 * said manufacturer's laptops are configured in such a way
689 * the nouveau decides an entry in the VBIOS FP mode table is
690 * valid - it's not (rh#613284)
692 if (nv_encoder
->dcb
->lvdsconf
.use_acpi_for_edid
) {
693 if ((nv_connector
->edid
= nouveau_acpi_edid(dev
, connector
))) {
694 status
= connector_status_connected
;
699 /* If no EDID found above, and the VBIOS indicates a hardcoded
700 * modeline is avalilable for the panel, set it as the panel's
701 * native mode and exit.
703 if (nouveau_bios_fp_mode(dev
, NULL
) && (drm
->vbios
.fp_no_ddc
||
704 nv_encoder
->dcb
->lvdsconf
.use_straps_for_mode
)) {
705 status
= connector_status_connected
;
709 /* Still nothing, some VBIOS images have a hardcoded EDID block
710 * stored for the panel stored in them.
712 if (!drm
->vbios
.fp_no_ddc
) {
714 (struct edid
*)nouveau_bios_embedded_edid(dev
);
717 kmemdup(edid
, EDID_LENGTH
, GFP_KERNEL
);
718 if (nv_connector
->edid
)
719 status
= connector_status_connected
;
724 #if defined(CONFIG_ACPI_BUTTON) || \
725 (defined(CONFIG_ACPI_BUTTON_MODULE) && defined(MODULE))
726 if (status
== connector_status_connected
&&
727 !nouveau_ignorelid
&& !acpi_lid_open())
728 status
= connector_status_unknown
;
731 drm_mode_connector_update_edid_property(connector
, nv_connector
->edid
);
732 nouveau_connector_set_encoder(connector
, nv_encoder
);
737 nouveau_connector_force(struct drm_connector
*connector
)
739 struct nouveau_drm
*drm
= nouveau_drm(connector
->dev
);
740 struct nouveau_connector
*nv_connector
= nouveau_connector(connector
);
741 struct nouveau_encoder
*nv_encoder
;
744 if (nv_connector
->type
== DCB_CONNECTOR_DVI_I
) {
745 if (connector
->force
== DRM_FORCE_ON_DIGITAL
)
746 type
= DCB_OUTPUT_TMDS
;
748 type
= DCB_OUTPUT_ANALOG
;
750 type
= DCB_OUTPUT_ANY
;
752 nv_encoder
= find_encoder(connector
, type
);
754 NV_ERROR(drm
, "can't find encoder to force %s on!\n",
756 connector
->status
= connector_status_disconnected
;
760 nouveau_connector_set_encoder(connector
, nv_encoder
);
764 nouveau_connector_set_property(struct drm_connector
*connector
,
765 struct drm_property
*property
, uint64_t value
)
767 struct nouveau_conn_atom
*asyc
= nouveau_conn_atom(connector
->state
);
768 struct nouveau_connector
*nv_connector
= nouveau_connector(connector
);
769 struct nouveau_encoder
*nv_encoder
= nv_connector
->detected_encoder
;
770 struct drm_encoder
*encoder
= to_drm_encoder(nv_encoder
);
773 ret
= connector
->funcs
->atomic_set_property(&nv_connector
->base
,
777 if (nv_encoder
&& nv_encoder
->dcb
->type
== DCB_OUTPUT_TV
)
778 return get_slave_funcs(encoder
)->set_property(
779 encoder
, connector
, property
, value
);
783 nv_connector
->scaling_mode
= asyc
->scaler
.mode
;
784 nv_connector
->dithering_mode
= asyc
->dither
.mode
;
786 if (connector
->encoder
&& connector
->encoder
->crtc
) {
787 ret
= drm_crtc_helper_set_mode(connector
->encoder
->crtc
,
788 &connector
->encoder
->crtc
->mode
,
789 connector
->encoder
->crtc
->x
,
790 connector
->encoder
->crtc
->y
,
804 static struct moderec scaler_modes
[] = {
823 nouveau_connector_scaler_modes_add(struct drm_connector
*connector
)
825 struct nouveau_connector
*nv_connector
= nouveau_connector(connector
);
826 struct drm_display_mode
*native
= nv_connector
->native_mode
, *m
;
827 struct drm_device
*dev
= connector
->dev
;
828 struct moderec
*mode
= &scaler_modes
[0];
834 while (mode
->hdisplay
) {
835 if (mode
->hdisplay
<= native
->hdisplay
&&
836 mode
->vdisplay
<= native
->vdisplay
&&
837 (mode
->hdisplay
!= native
->hdisplay
||
838 mode
->vdisplay
!= native
->vdisplay
)) {
839 m
= drm_cvt_mode(dev
, mode
->hdisplay
, mode
->vdisplay
,
840 drm_mode_vrefresh(native
), false,
845 drm_mode_probed_add(connector
, m
);
856 nouveau_connector_detect_depth(struct drm_connector
*connector
)
858 struct nouveau_drm
*drm
= nouveau_drm(connector
->dev
);
859 struct nouveau_connector
*nv_connector
= nouveau_connector(connector
);
860 struct nouveau_encoder
*nv_encoder
= nv_connector
->detected_encoder
;
861 struct nvbios
*bios
= &drm
->vbios
;
862 struct drm_display_mode
*mode
= nv_connector
->native_mode
;
865 /* if the edid is feeling nice enough to provide this info, use it */
866 if (nv_connector
->edid
&& connector
->display_info
.bpc
)
869 /* EDID 1.4 is *supposed* to be supported on eDP, but, Apple... */
870 if (nv_connector
->type
== DCB_CONNECTOR_eDP
) {
871 connector
->display_info
.bpc
= 6;
875 /* we're out of options unless we're LVDS, default to 8bpc */
876 if (nv_encoder
->dcb
->type
!= DCB_OUTPUT_LVDS
) {
877 connector
->display_info
.bpc
= 8;
881 connector
->display_info
.bpc
= 6;
883 /* LVDS: panel straps */
884 if (bios
->fp_no_ddc
) {
885 if (bios
->fp
.if_is_24bit
)
886 connector
->display_info
.bpc
= 8;
890 /* LVDS: DDC panel, need to first determine the number of links to
891 * know which if_is_24bit flag to check...
893 if (nv_connector
->edid
&&
894 nv_connector
->type
== DCB_CONNECTOR_LVDS_SPWG
)
895 duallink
= ((u8
*)nv_connector
->edid
)[121] == 2;
897 duallink
= mode
->clock
>= bios
->fp
.duallink_transition_clk
;
899 if ((!duallink
&& (bios
->fp
.strapless_is_24bit
& 1)) ||
900 ( duallink
&& (bios
->fp
.strapless_is_24bit
& 2)))
901 connector
->display_info
.bpc
= 8;
905 nouveau_connector_get_modes(struct drm_connector
*connector
)
907 struct drm_device
*dev
= connector
->dev
;
908 struct nouveau_drm
*drm
= nouveau_drm(dev
);
909 struct nouveau_connector
*nv_connector
= nouveau_connector(connector
);
910 struct nouveau_encoder
*nv_encoder
= nv_connector
->detected_encoder
;
911 struct drm_encoder
*encoder
= to_drm_encoder(nv_encoder
);
914 /* destroy the native mode, the attached monitor could have changed.
916 if (nv_connector
->native_mode
) {
917 drm_mode_destroy(dev
, nv_connector
->native_mode
);
918 nv_connector
->native_mode
= NULL
;
921 if (nv_connector
->edid
)
922 ret
= drm_add_edid_modes(connector
, nv_connector
->edid
);
924 if (nv_encoder
->dcb
->type
== DCB_OUTPUT_LVDS
&&
925 (nv_encoder
->dcb
->lvdsconf
.use_straps_for_mode
||
926 drm
->vbios
.fp_no_ddc
) && nouveau_bios_fp_mode(dev
, NULL
)) {
927 struct drm_display_mode mode
;
929 nouveau_bios_fp_mode(dev
, &mode
);
930 nv_connector
->native_mode
= drm_mode_duplicate(dev
, &mode
);
933 /* Determine display colour depth for everything except LVDS now,
934 * DP requires this before mode_valid() is called.
936 if (connector
->connector_type
!= DRM_MODE_CONNECTOR_LVDS
)
937 nouveau_connector_detect_depth(connector
);
939 /* Find the native mode if this is a digital panel, if we didn't
940 * find any modes through DDC previously add the native mode to
943 if (!nv_connector
->native_mode
)
944 nv_connector
->native_mode
= nouveau_conn_native_mode(connector
);
945 if (ret
== 0 && nv_connector
->native_mode
) {
946 struct drm_display_mode
*mode
;
948 mode
= drm_mode_duplicate(dev
, nv_connector
->native_mode
);
949 drm_mode_probed_add(connector
, mode
);
953 /* Determine LVDS colour depth, must happen after determining
954 * "native" mode as some VBIOS tables require us to use the
955 * pixel clock as part of the lookup...
957 if (connector
->connector_type
== DRM_MODE_CONNECTOR_LVDS
)
958 nouveau_connector_detect_depth(connector
);
960 if (nv_encoder
->dcb
->type
== DCB_OUTPUT_TV
)
961 ret
= get_slave_funcs(encoder
)->get_modes(encoder
, connector
);
963 if (nv_connector
->type
== DCB_CONNECTOR_LVDS
||
964 nv_connector
->type
== DCB_CONNECTOR_LVDS_SPWG
||
965 nv_connector
->type
== DCB_CONNECTOR_eDP
)
966 ret
+= nouveau_connector_scaler_modes_add(connector
);
972 get_tmds_link_bandwidth(struct drm_connector
*connector
, bool hdmi
)
974 struct nouveau_connector
*nv_connector
= nouveau_connector(connector
);
975 struct nouveau_drm
*drm
= nouveau_drm(connector
->dev
);
976 struct dcb_output
*dcb
= nv_connector
->detected_encoder
->dcb
;
979 if (nouveau_hdmimhz
> 0)
980 return nouveau_hdmimhz
* 1000;
981 /* Note: these limits are conservative, some Fermi's
982 * can do 297 MHz. Unclear how this can be determined.
984 if (drm
->client
.device
.info
.family
>= NV_DEVICE_INFO_V0_KEPLER
)
986 if (drm
->client
.device
.info
.family
>= NV_DEVICE_INFO_V0_FERMI
)
989 if (dcb
->location
!= DCB_LOC_ON_CHIP
||
990 drm
->client
.device
.info
.chipset
>= 0x46)
992 else if (drm
->client
.device
.info
.chipset
>= 0x40)
994 else if (drm
->client
.device
.info
.chipset
>= 0x18)
1001 nouveau_connector_mode_valid(struct drm_connector
*connector
,
1002 struct drm_display_mode
*mode
)
1004 struct nouveau_connector
*nv_connector
= nouveau_connector(connector
);
1005 struct nouveau_encoder
*nv_encoder
= nv_connector
->detected_encoder
;
1006 struct drm_encoder
*encoder
= to_drm_encoder(nv_encoder
);
1007 unsigned min_clock
= 25000, max_clock
= min_clock
;
1008 unsigned clock
= mode
->clock
;
1011 switch (nv_encoder
->dcb
->type
) {
1012 case DCB_OUTPUT_LVDS
:
1013 if (nv_connector
->native_mode
&&
1014 (mode
->hdisplay
> nv_connector
->native_mode
->hdisplay
||
1015 mode
->vdisplay
> nv_connector
->native_mode
->vdisplay
))
1021 case DCB_OUTPUT_TMDS
:
1022 hdmi
= drm_detect_hdmi_monitor(nv_connector
->edid
);
1023 max_clock
= get_tmds_link_bandwidth(connector
, hdmi
);
1024 if (!hdmi
&& nouveau_duallink
&&
1025 nv_encoder
->dcb
->duallink_possible
)
1028 case DCB_OUTPUT_ANALOG
:
1029 max_clock
= nv_encoder
->dcb
->crtconf
.maxfreq
;
1034 return get_slave_funcs(encoder
)->mode_valid(encoder
, mode
);
1036 max_clock
= nv_encoder
->dp
.link_nr
;
1037 max_clock
*= nv_encoder
->dp
.link_bw
;
1038 clock
= clock
* (connector
->display_info
.bpc
* 3) / 10;
1045 if ((mode
->flags
& DRM_MODE_FLAG_3D_MASK
) == DRM_MODE_FLAG_3D_FRAME_PACKING
)
1048 if (clock
< min_clock
)
1049 return MODE_CLOCK_LOW
;
1051 if (clock
> max_clock
)
1052 return MODE_CLOCK_HIGH
;
1057 static struct drm_encoder
*
1058 nouveau_connector_best_encoder(struct drm_connector
*connector
)
1060 struct nouveau_connector
*nv_connector
= nouveau_connector(connector
);
1062 if (nv_connector
->detected_encoder
)
1063 return to_drm_encoder(nv_connector
->detected_encoder
);
1068 static const struct drm_connector_helper_funcs
1069 nouveau_connector_helper_funcs
= {
1070 .get_modes
= nouveau_connector_get_modes
,
1071 .mode_valid
= nouveau_connector_mode_valid
,
1072 .best_encoder
= nouveau_connector_best_encoder
,
1075 static const struct drm_connector_funcs
1076 nouveau_connector_funcs
= {
1077 .dpms
= drm_helper_connector_dpms
,
1078 .reset
= nouveau_conn_reset
,
1079 .detect
= nouveau_connector_detect
,
1080 .force
= nouveau_connector_force
,
1081 .fill_modes
= drm_helper_probe_single_connector_modes
,
1082 .set_property
= nouveau_connector_set_property
,
1083 .destroy
= nouveau_connector_destroy
,
1084 .atomic_duplicate_state
= nouveau_conn_atomic_duplicate_state
,
1085 .atomic_destroy_state
= nouveau_conn_atomic_destroy_state
,
1086 .atomic_set_property
= nouveau_conn_atomic_set_property
,
1087 .atomic_get_property
= nouveau_conn_atomic_get_property
,
1090 static const struct drm_connector_funcs
1091 nouveau_connector_funcs_lvds
= {
1092 .dpms
= drm_helper_connector_dpms
,
1093 .reset
= nouveau_conn_reset
,
1094 .detect
= nouveau_connector_detect_lvds
,
1095 .force
= nouveau_connector_force
,
1096 .fill_modes
= drm_helper_probe_single_connector_modes
,
1097 .set_property
= nouveau_connector_set_property
,
1098 .destroy
= nouveau_connector_destroy
,
1099 .atomic_duplicate_state
= nouveau_conn_atomic_duplicate_state
,
1100 .atomic_destroy_state
= nouveau_conn_atomic_destroy_state
,
1101 .atomic_set_property
= nouveau_conn_atomic_set_property
,
1102 .atomic_get_property
= nouveau_conn_atomic_get_property
,
1106 nouveau_connector_hotplug(struct nvif_notify
*notify
)
1108 struct nouveau_connector
*nv_connector
=
1109 container_of(notify
, typeof(*nv_connector
), hpd
);
1110 struct drm_connector
*connector
= &nv_connector
->base
;
1111 struct nouveau_drm
*drm
= nouveau_drm(connector
->dev
);
1112 const struct nvif_notify_conn_rep_v0
*rep
= notify
->data
;
1113 const char *name
= connector
->name
;
1114 struct nouveau_encoder
*nv_encoder
;
1116 if (rep
->mask
& NVIF_NOTIFY_CONN_V0_IRQ
) {
1117 NV_DEBUG(drm
, "service %s\n", name
);
1118 if ((nv_encoder
= find_encoder(connector
, DCB_OUTPUT_DP
)))
1119 nv50_mstm_service(nv_encoder
->dp
.mstm
);
1121 bool plugged
= (rep
->mask
!= NVIF_NOTIFY_CONN_V0_UNPLUG
);
1123 NV_DEBUG(drm
, "%splugged %s\n", plugged
? "" : "un", name
);
1124 if ((nv_encoder
= find_encoder(connector
, DCB_OUTPUT_DP
))) {
1126 nv50_mstm_remove(nv_encoder
->dp
.mstm
);
1129 drm_helper_hpd_irq_event(connector
->dev
);
1132 return NVIF_NOTIFY_KEEP
;
1136 nouveau_connector_aux_xfer(struct drm_dp_aux
*obj
, struct drm_dp_aux_msg
*msg
)
1138 struct nouveau_connector
*nv_connector
=
1139 container_of(obj
, typeof(*nv_connector
), aux
);
1140 struct nouveau_encoder
*nv_encoder
;
1141 struct nvkm_i2c_aux
*aux
;
1142 u8 size
= msg
->size
;
1145 nv_encoder
= find_encoder(&nv_connector
->base
, DCB_OUTPUT_DP
);
1146 if (!nv_encoder
|| !(aux
= nv_encoder
->aux
))
1148 if (WARN_ON(msg
->size
> 16))
1151 ret
= nvkm_i2c_aux_acquire(aux
);
1155 ret
= nvkm_i2c_aux_xfer(aux
, false, msg
->request
, msg
->address
,
1156 msg
->buffer
, &size
);
1157 nvkm_i2c_aux_release(aux
);
1167 drm_conntype_from_dcb(enum dcb_connector_type dcb
)
1170 case DCB_CONNECTOR_VGA
: return DRM_MODE_CONNECTOR_VGA
;
1171 case DCB_CONNECTOR_TV_0
:
1172 case DCB_CONNECTOR_TV_1
:
1173 case DCB_CONNECTOR_TV_3
: return DRM_MODE_CONNECTOR_TV
;
1174 case DCB_CONNECTOR_DMS59_0
:
1175 case DCB_CONNECTOR_DMS59_1
:
1176 case DCB_CONNECTOR_DVI_I
: return DRM_MODE_CONNECTOR_DVII
;
1177 case DCB_CONNECTOR_DVI_D
: return DRM_MODE_CONNECTOR_DVID
;
1178 case DCB_CONNECTOR_LVDS
:
1179 case DCB_CONNECTOR_LVDS_SPWG
: return DRM_MODE_CONNECTOR_LVDS
;
1180 case DCB_CONNECTOR_DMS59_DP0
:
1181 case DCB_CONNECTOR_DMS59_DP1
:
1182 case DCB_CONNECTOR_DP
: return DRM_MODE_CONNECTOR_DisplayPort
;
1183 case DCB_CONNECTOR_eDP
: return DRM_MODE_CONNECTOR_eDP
;
1184 case DCB_CONNECTOR_HDMI_0
:
1185 case DCB_CONNECTOR_HDMI_1
:
1186 case DCB_CONNECTOR_HDMI_C
: return DRM_MODE_CONNECTOR_HDMIA
;
1187 case DCB_CONNECTOR_WFD
: return DRM_MODE_CONNECTOR_VIRTUAL
;
1192 return DRM_MODE_CONNECTOR_Unknown
;
1195 struct drm_connector
*
1196 nouveau_connector_create(struct drm_device
*dev
, int index
)
1198 const struct drm_connector_funcs
*funcs
= &nouveau_connector_funcs
;
1199 struct nouveau_drm
*drm
= nouveau_drm(dev
);
1200 struct nouveau_display
*disp
= nouveau_display(dev
);
1201 struct nouveau_connector
*nv_connector
= NULL
;
1202 struct drm_connector
*connector
;
1206 list_for_each_entry(connector
, &dev
->mode_config
.connector_list
, head
) {
1207 nv_connector
= nouveau_connector(connector
);
1208 if (nv_connector
->index
== index
)
1212 nv_connector
= kzalloc(sizeof(*nv_connector
), GFP_KERNEL
);
1214 return ERR_PTR(-ENOMEM
);
1216 connector
= &nv_connector
->base
;
1217 nv_connector
->index
= index
;
1219 /* attempt to parse vbios connector type and hotplug gpio */
1220 nv_connector
->dcb
= olddcb_conn(dev
, index
);
1221 if (nv_connector
->dcb
) {
1222 u32 entry
= ROM16(nv_connector
->dcb
[0]);
1223 if (olddcb_conntab(dev
)[3] >= 4)
1224 entry
|= (u32
)ROM16(nv_connector
->dcb
[2]) << 16;
1226 nv_connector
->type
= nv_connector
->dcb
[0];
1227 if (drm_conntype_from_dcb(nv_connector
->type
) ==
1228 DRM_MODE_CONNECTOR_Unknown
) {
1229 NV_WARN(drm
, "unknown connector type %02x\n",
1230 nv_connector
->type
);
1231 nv_connector
->type
= DCB_CONNECTOR_NONE
;
1234 /* Gigabyte NX85T */
1235 if (nv_match_device(dev
, 0x0421, 0x1458, 0x344c)) {
1236 if (nv_connector
->type
== DCB_CONNECTOR_HDMI_1
)
1237 nv_connector
->type
= DCB_CONNECTOR_DVI_I
;
1240 /* Gigabyte GV-NX86T512H */
1241 if (nv_match_device(dev
, 0x0402, 0x1458, 0x3455)) {
1242 if (nv_connector
->type
== DCB_CONNECTOR_HDMI_1
)
1243 nv_connector
->type
= DCB_CONNECTOR_DVI_I
;
1246 nv_connector
->type
= DCB_CONNECTOR_NONE
;
1249 /* no vbios data, or an unknown dcb connector type - attempt to
1250 * figure out something suitable ourselves
1252 if (nv_connector
->type
== DCB_CONNECTOR_NONE
) {
1253 struct nouveau_drm
*drm
= nouveau_drm(dev
);
1254 struct dcb_table
*dcbt
= &drm
->vbios
.dcb
;
1258 for (i
= 0; i
< dcbt
->entries
; i
++) {
1259 if (dcbt
->entry
[i
].connector
== nv_connector
->index
)
1260 encoders
|= (1 << dcbt
->entry
[i
].type
);
1263 if (encoders
& (1 << DCB_OUTPUT_DP
)) {
1264 if (encoders
& (1 << DCB_OUTPUT_TMDS
))
1265 nv_connector
->type
= DCB_CONNECTOR_DP
;
1267 nv_connector
->type
= DCB_CONNECTOR_eDP
;
1269 if (encoders
& (1 << DCB_OUTPUT_TMDS
)) {
1270 if (encoders
& (1 << DCB_OUTPUT_ANALOG
))
1271 nv_connector
->type
= DCB_CONNECTOR_DVI_I
;
1273 nv_connector
->type
= DCB_CONNECTOR_DVI_D
;
1275 if (encoders
& (1 << DCB_OUTPUT_ANALOG
)) {
1276 nv_connector
->type
= DCB_CONNECTOR_VGA
;
1278 if (encoders
& (1 << DCB_OUTPUT_LVDS
)) {
1279 nv_connector
->type
= DCB_CONNECTOR_LVDS
;
1281 if (encoders
& (1 << DCB_OUTPUT_TV
)) {
1282 nv_connector
->type
= DCB_CONNECTOR_TV_0
;
1286 switch ((type
= drm_conntype_from_dcb(nv_connector
->type
))) {
1287 case DRM_MODE_CONNECTOR_LVDS
:
1288 ret
= nouveau_bios_parse_lvds_table(dev
, 0, &dummy
, &dummy
);
1290 NV_ERROR(drm
, "Error parsing LVDS table, disabling\n");
1291 kfree(nv_connector
);
1292 return ERR_PTR(ret
);
1295 funcs
= &nouveau_connector_funcs_lvds
;
1297 case DRM_MODE_CONNECTOR_DisplayPort
:
1298 case DRM_MODE_CONNECTOR_eDP
:
1299 nv_connector
->aux
.dev
= dev
->dev
;
1300 nv_connector
->aux
.transfer
= nouveau_connector_aux_xfer
;
1301 ret
= drm_dp_aux_register(&nv_connector
->aux
);
1303 NV_ERROR(drm
, "failed to register aux channel\n");
1304 kfree(nv_connector
);
1305 return ERR_PTR(ret
);
1308 funcs
= &nouveau_connector_funcs
;
1311 funcs
= &nouveau_connector_funcs
;
1315 /* HDMI 3D support */
1316 if ((disp
->disp
.oclass
>= G82_DISP
)
1317 && ((type
== DRM_MODE_CONNECTOR_DisplayPort
)
1318 || (type
== DRM_MODE_CONNECTOR_eDP
)
1319 || (type
== DRM_MODE_CONNECTOR_HDMIA
)))
1320 connector
->stereo_allowed
= true;
1322 /* defaults, will get overridden in detect() */
1323 connector
->interlace_allowed
= false;
1324 connector
->doublescan_allowed
= false;
1326 drm_connector_init(dev
, connector
, funcs
, type
);
1327 drm_connector_helper_add(connector
, &nouveau_connector_helper_funcs
);
1329 connector
->funcs
->reset(connector
);
1330 nouveau_conn_attach_properties(connector
);
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
;
1342 nv_connector
->scaling_mode
= DRM_MODE_SCALE_NONE
;
1345 nv_connector
->scaling_mode
= DRM_MODE_SCALE_NONE
;
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
:
1357 nv_connector
->dithering_mode
= DITHERING_MODE_AUTO
;
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
,
1367 sizeof(struct nvif_notify_conn_req_v0
),
1368 sizeof(struct nvif_notify_conn_rep_v0
),
1369 &nv_connector
->hpd
);
1371 connector
->polled
= DRM_CONNECTOR_POLL_CONNECT
;
1373 connector
->polled
= DRM_CONNECTOR_POLL_HPD
;
1375 drm_connector_register(connector
);