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 if (drm_drv_uses_atomic_modeset(connector
->dev
))
774 return drm_atomic_helper_connector_set_property(connector
, property
, value
);
776 ret
= connector
->funcs
->atomic_set_property(&nv_connector
->base
,
780 if (nv_encoder
&& nv_encoder
->dcb
->type
== DCB_OUTPUT_TV
)
781 return get_slave_funcs(encoder
)->set_property(
782 encoder
, connector
, property
, value
);
786 nv_connector
->scaling_mode
= asyc
->scaler
.mode
;
787 nv_connector
->dithering_mode
= asyc
->dither
.mode
;
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
,
807 static struct moderec scaler_modes
[] = {
826 nouveau_connector_scaler_modes_add(struct drm_connector
*connector
)
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];
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,
848 drm_mode_probed_add(connector
, m
);
859 nouveau_connector_detect_depth(struct drm_connector
*connector
)
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
;
868 /* if the edid is feeling nice enough to provide this info, use it */
869 if (nv_connector
->edid
&& connector
->display_info
.bpc
)
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;
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;
884 connector
->display_info
.bpc
= 6;
886 /* LVDS: panel straps */
887 if (bios
->fp_no_ddc
) {
888 if (bios
->fp
.if_is_24bit
)
889 connector
->display_info
.bpc
= 8;
893 /* LVDS: DDC panel, need to first determine the number of links to
894 * know which if_is_24bit flag to check...
896 if (nv_connector
->edid
&&
897 nv_connector
->type
== DCB_CONNECTOR_LVDS_SPWG
)
898 duallink
= ((u8
*)nv_connector
->edid
)[121] == 2;
900 duallink
= mode
->clock
>= bios
->fp
.duallink_transition_clk
;
902 if ((!duallink
&& (bios
->fp
.strapless_is_24bit
& 1)) ||
903 ( duallink
&& (bios
->fp
.strapless_is_24bit
& 2)))
904 connector
->display_info
.bpc
= 8;
908 nouveau_connector_get_modes(struct drm_connector
*connector
)
910 struct drm_device
*dev
= connector
->dev
;
911 struct nouveau_drm
*drm
= nouveau_drm(dev
);
912 struct nouveau_connector
*nv_connector
= nouveau_connector(connector
);
913 struct nouveau_encoder
*nv_encoder
= nv_connector
->detected_encoder
;
914 struct drm_encoder
*encoder
= to_drm_encoder(nv_encoder
);
917 /* destroy the native mode, the attached monitor could have changed.
919 if (nv_connector
->native_mode
) {
920 drm_mode_destroy(dev
, nv_connector
->native_mode
);
921 nv_connector
->native_mode
= NULL
;
924 if (nv_connector
->edid
)
925 ret
= drm_add_edid_modes(connector
, nv_connector
->edid
);
927 if (nv_encoder
->dcb
->type
== DCB_OUTPUT_LVDS
&&
928 (nv_encoder
->dcb
->lvdsconf
.use_straps_for_mode
||
929 drm
->vbios
.fp_no_ddc
) && nouveau_bios_fp_mode(dev
, NULL
)) {
930 struct drm_display_mode mode
;
932 nouveau_bios_fp_mode(dev
, &mode
);
933 nv_connector
->native_mode
= drm_mode_duplicate(dev
, &mode
);
936 /* Determine display colour depth for everything except LVDS now,
937 * DP requires this before mode_valid() is called.
939 if (connector
->connector_type
!= DRM_MODE_CONNECTOR_LVDS
)
940 nouveau_connector_detect_depth(connector
);
942 /* Find the native mode if this is a digital panel, if we didn't
943 * find any modes through DDC previously add the native mode to
946 if (!nv_connector
->native_mode
)
947 nv_connector
->native_mode
= nouveau_conn_native_mode(connector
);
948 if (ret
== 0 && nv_connector
->native_mode
) {
949 struct drm_display_mode
*mode
;
951 mode
= drm_mode_duplicate(dev
, nv_connector
->native_mode
);
952 drm_mode_probed_add(connector
, mode
);
956 /* Determine LVDS colour depth, must happen after determining
957 * "native" mode as some VBIOS tables require us to use the
958 * pixel clock as part of the lookup...
960 if (connector
->connector_type
== DRM_MODE_CONNECTOR_LVDS
)
961 nouveau_connector_detect_depth(connector
);
963 if (nv_encoder
->dcb
->type
== DCB_OUTPUT_TV
)
964 ret
= get_slave_funcs(encoder
)->get_modes(encoder
, connector
);
966 if (nv_connector
->type
== DCB_CONNECTOR_LVDS
||
967 nv_connector
->type
== DCB_CONNECTOR_LVDS_SPWG
||
968 nv_connector
->type
== DCB_CONNECTOR_eDP
)
969 ret
+= nouveau_connector_scaler_modes_add(connector
);
975 get_tmds_link_bandwidth(struct drm_connector
*connector
, bool hdmi
)
977 struct nouveau_connector
*nv_connector
= nouveau_connector(connector
);
978 struct nouveau_drm
*drm
= nouveau_drm(connector
->dev
);
979 struct dcb_output
*dcb
= nv_connector
->detected_encoder
->dcb
;
982 if (nouveau_hdmimhz
> 0)
983 return nouveau_hdmimhz
* 1000;
984 /* Note: these limits are conservative, some Fermi's
985 * can do 297 MHz. Unclear how this can be determined.
987 if (drm
->client
.device
.info
.family
>= NV_DEVICE_INFO_V0_KEPLER
)
989 if (drm
->client
.device
.info
.family
>= NV_DEVICE_INFO_V0_FERMI
)
992 if (dcb
->location
!= DCB_LOC_ON_CHIP
||
993 drm
->client
.device
.info
.chipset
>= 0x46)
995 else if (drm
->client
.device
.info
.chipset
>= 0x40)
997 else if (drm
->client
.device
.info
.chipset
>= 0x18)
1004 nouveau_connector_mode_valid(struct drm_connector
*connector
,
1005 struct drm_display_mode
*mode
)
1007 struct nouveau_connector
*nv_connector
= nouveau_connector(connector
);
1008 struct nouveau_encoder
*nv_encoder
= nv_connector
->detected_encoder
;
1009 struct drm_encoder
*encoder
= to_drm_encoder(nv_encoder
);
1010 unsigned min_clock
= 25000, max_clock
= min_clock
;
1011 unsigned clock
= mode
->clock
;
1014 switch (nv_encoder
->dcb
->type
) {
1015 case DCB_OUTPUT_LVDS
:
1016 if (nv_connector
->native_mode
&&
1017 (mode
->hdisplay
> nv_connector
->native_mode
->hdisplay
||
1018 mode
->vdisplay
> nv_connector
->native_mode
->vdisplay
))
1024 case DCB_OUTPUT_TMDS
:
1025 hdmi
= drm_detect_hdmi_monitor(nv_connector
->edid
);
1026 max_clock
= get_tmds_link_bandwidth(connector
, hdmi
);
1027 if (!hdmi
&& nouveau_duallink
&&
1028 nv_encoder
->dcb
->duallink_possible
)
1031 case DCB_OUTPUT_ANALOG
:
1032 max_clock
= nv_encoder
->dcb
->crtconf
.maxfreq
;
1037 return get_slave_funcs(encoder
)->mode_valid(encoder
, mode
);
1039 max_clock
= nv_encoder
->dp
.link_nr
;
1040 max_clock
*= nv_encoder
->dp
.link_bw
;
1041 clock
= clock
* (connector
->display_info
.bpc
* 3) / 10;
1048 if ((mode
->flags
& DRM_MODE_FLAG_3D_MASK
) == DRM_MODE_FLAG_3D_FRAME_PACKING
)
1051 if (clock
< min_clock
)
1052 return MODE_CLOCK_LOW
;
1054 if (clock
> max_clock
)
1055 return MODE_CLOCK_HIGH
;
1060 static struct drm_encoder
*
1061 nouveau_connector_best_encoder(struct drm_connector
*connector
)
1063 struct nouveau_connector
*nv_connector
= nouveau_connector(connector
);
1065 if (nv_connector
->detected_encoder
)
1066 return to_drm_encoder(nv_connector
->detected_encoder
);
1071 static const struct drm_connector_helper_funcs
1072 nouveau_connector_helper_funcs
= {
1073 .get_modes
= nouveau_connector_get_modes
,
1074 .mode_valid
= nouveau_connector_mode_valid
,
1075 .best_encoder
= nouveau_connector_best_encoder
,
1079 nouveau_connector_dpms(struct drm_connector
*connector
, int mode
)
1081 if (drm_drv_uses_atomic_modeset(connector
->dev
))
1082 return drm_atomic_helper_connector_dpms(connector
, mode
);
1083 return drm_helper_connector_dpms(connector
, mode
);
1086 static const struct drm_connector_funcs
1087 nouveau_connector_funcs
= {
1088 .dpms
= nouveau_connector_dpms
,
1089 .reset
= nouveau_conn_reset
,
1090 .detect
= nouveau_connector_detect
,
1091 .force
= nouveau_connector_force
,
1092 .fill_modes
= drm_helper_probe_single_connector_modes
,
1093 .set_property
= nouveau_connector_set_property
,
1094 .destroy
= nouveau_connector_destroy
,
1095 .atomic_duplicate_state
= nouveau_conn_atomic_duplicate_state
,
1096 .atomic_destroy_state
= nouveau_conn_atomic_destroy_state
,
1097 .atomic_set_property
= nouveau_conn_atomic_set_property
,
1098 .atomic_get_property
= nouveau_conn_atomic_get_property
,
1101 static const struct drm_connector_funcs
1102 nouveau_connector_funcs_lvds
= {
1103 .dpms
= nouveau_connector_dpms
,
1104 .reset
= nouveau_conn_reset
,
1105 .detect
= nouveau_connector_detect_lvds
,
1106 .force
= nouveau_connector_force
,
1107 .fill_modes
= drm_helper_probe_single_connector_modes
,
1108 .set_property
= nouveau_connector_set_property
,
1109 .destroy
= nouveau_connector_destroy
,
1110 .atomic_duplicate_state
= nouveau_conn_atomic_duplicate_state
,
1111 .atomic_destroy_state
= nouveau_conn_atomic_destroy_state
,
1112 .atomic_set_property
= nouveau_conn_atomic_set_property
,
1113 .atomic_get_property
= nouveau_conn_atomic_get_property
,
1117 nouveau_connector_hotplug(struct nvif_notify
*notify
)
1119 struct nouveau_connector
*nv_connector
=
1120 container_of(notify
, typeof(*nv_connector
), hpd
);
1121 struct drm_connector
*connector
= &nv_connector
->base
;
1122 struct nouveau_drm
*drm
= nouveau_drm(connector
->dev
);
1123 const struct nvif_notify_conn_rep_v0
*rep
= notify
->data
;
1124 const char *name
= connector
->name
;
1125 struct nouveau_encoder
*nv_encoder
;
1127 if (rep
->mask
& NVIF_NOTIFY_CONN_V0_IRQ
) {
1128 NV_DEBUG(drm
, "service %s\n", name
);
1129 if ((nv_encoder
= find_encoder(connector
, DCB_OUTPUT_DP
)))
1130 nv50_mstm_service(nv_encoder
->dp
.mstm
);
1132 bool plugged
= (rep
->mask
!= NVIF_NOTIFY_CONN_V0_UNPLUG
);
1134 NV_DEBUG(drm
, "%splugged %s\n", plugged
? "" : "un", name
);
1135 if ((nv_encoder
= find_encoder(connector
, DCB_OUTPUT_DP
))) {
1137 nv50_mstm_remove(nv_encoder
->dp
.mstm
);
1140 drm_helper_hpd_irq_event(connector
->dev
);
1143 return NVIF_NOTIFY_KEEP
;
1147 nouveau_connector_aux_xfer(struct drm_dp_aux
*obj
, struct drm_dp_aux_msg
*msg
)
1149 struct nouveau_connector
*nv_connector
=
1150 container_of(obj
, typeof(*nv_connector
), aux
);
1151 struct nouveau_encoder
*nv_encoder
;
1152 struct nvkm_i2c_aux
*aux
;
1153 u8 size
= msg
->size
;
1156 nv_encoder
= find_encoder(&nv_connector
->base
, DCB_OUTPUT_DP
);
1157 if (!nv_encoder
|| !(aux
= nv_encoder
->aux
))
1159 if (WARN_ON(msg
->size
> 16))
1162 ret
= nvkm_i2c_aux_acquire(aux
);
1166 ret
= nvkm_i2c_aux_xfer(aux
, false, msg
->request
, msg
->address
,
1167 msg
->buffer
, &size
);
1168 nvkm_i2c_aux_release(aux
);
1178 drm_conntype_from_dcb(enum dcb_connector_type dcb
)
1181 case DCB_CONNECTOR_VGA
: return DRM_MODE_CONNECTOR_VGA
;
1182 case DCB_CONNECTOR_TV_0
:
1183 case DCB_CONNECTOR_TV_1
:
1184 case DCB_CONNECTOR_TV_3
: return DRM_MODE_CONNECTOR_TV
;
1185 case DCB_CONNECTOR_DMS59_0
:
1186 case DCB_CONNECTOR_DMS59_1
:
1187 case DCB_CONNECTOR_DVI_I
: return DRM_MODE_CONNECTOR_DVII
;
1188 case DCB_CONNECTOR_DVI_D
: return DRM_MODE_CONNECTOR_DVID
;
1189 case DCB_CONNECTOR_LVDS
:
1190 case DCB_CONNECTOR_LVDS_SPWG
: return DRM_MODE_CONNECTOR_LVDS
;
1191 case DCB_CONNECTOR_DMS59_DP0
:
1192 case DCB_CONNECTOR_DMS59_DP1
:
1193 case DCB_CONNECTOR_DP
: return DRM_MODE_CONNECTOR_DisplayPort
;
1194 case DCB_CONNECTOR_eDP
: return DRM_MODE_CONNECTOR_eDP
;
1195 case DCB_CONNECTOR_HDMI_0
:
1196 case DCB_CONNECTOR_HDMI_1
:
1197 case DCB_CONNECTOR_HDMI_C
: return DRM_MODE_CONNECTOR_HDMIA
;
1202 return DRM_MODE_CONNECTOR_Unknown
;
1205 struct drm_connector
*
1206 nouveau_connector_create(struct drm_device
*dev
, int index
)
1208 const struct drm_connector_funcs
*funcs
= &nouveau_connector_funcs
;
1209 struct nouveau_drm
*drm
= nouveau_drm(dev
);
1210 struct nouveau_display
*disp
= nouveau_display(dev
);
1211 struct nouveau_connector
*nv_connector
= NULL
;
1212 struct drm_connector
*connector
;
1216 list_for_each_entry(connector
, &dev
->mode_config
.connector_list
, head
) {
1217 nv_connector
= nouveau_connector(connector
);
1218 if (nv_connector
->index
== index
)
1222 nv_connector
= kzalloc(sizeof(*nv_connector
), GFP_KERNEL
);
1224 return ERR_PTR(-ENOMEM
);
1226 connector
= &nv_connector
->base
;
1227 nv_connector
->index
= index
;
1229 /* attempt to parse vbios connector type and hotplug gpio */
1230 nv_connector
->dcb
= olddcb_conn(dev
, index
);
1231 if (nv_connector
->dcb
) {
1232 u32 entry
= ROM16(nv_connector
->dcb
[0]);
1233 if (olddcb_conntab(dev
)[3] >= 4)
1234 entry
|= (u32
)ROM16(nv_connector
->dcb
[2]) << 16;
1236 nv_connector
->type
= nv_connector
->dcb
[0];
1237 if (drm_conntype_from_dcb(nv_connector
->type
) ==
1238 DRM_MODE_CONNECTOR_Unknown
) {
1239 NV_WARN(drm
, "unknown connector type %02x\n",
1240 nv_connector
->type
);
1241 nv_connector
->type
= DCB_CONNECTOR_NONE
;
1244 /* Gigabyte NX85T */
1245 if (nv_match_device(dev
, 0x0421, 0x1458, 0x344c)) {
1246 if (nv_connector
->type
== DCB_CONNECTOR_HDMI_1
)
1247 nv_connector
->type
= DCB_CONNECTOR_DVI_I
;
1250 /* Gigabyte GV-NX86T512H */
1251 if (nv_match_device(dev
, 0x0402, 0x1458, 0x3455)) {
1252 if (nv_connector
->type
== DCB_CONNECTOR_HDMI_1
)
1253 nv_connector
->type
= DCB_CONNECTOR_DVI_I
;
1256 nv_connector
->type
= DCB_CONNECTOR_NONE
;
1259 /* no vbios data, or an unknown dcb connector type - attempt to
1260 * figure out something suitable ourselves
1262 if (nv_connector
->type
== DCB_CONNECTOR_NONE
) {
1263 struct nouveau_drm
*drm
= nouveau_drm(dev
);
1264 struct dcb_table
*dcbt
= &drm
->vbios
.dcb
;
1268 for (i
= 0; i
< dcbt
->entries
; i
++) {
1269 if (dcbt
->entry
[i
].connector
== nv_connector
->index
)
1270 encoders
|= (1 << dcbt
->entry
[i
].type
);
1273 if (encoders
& (1 << DCB_OUTPUT_DP
)) {
1274 if (encoders
& (1 << DCB_OUTPUT_TMDS
))
1275 nv_connector
->type
= DCB_CONNECTOR_DP
;
1277 nv_connector
->type
= DCB_CONNECTOR_eDP
;
1279 if (encoders
& (1 << DCB_OUTPUT_TMDS
)) {
1280 if (encoders
& (1 << DCB_OUTPUT_ANALOG
))
1281 nv_connector
->type
= DCB_CONNECTOR_DVI_I
;
1283 nv_connector
->type
= DCB_CONNECTOR_DVI_D
;
1285 if (encoders
& (1 << DCB_OUTPUT_ANALOG
)) {
1286 nv_connector
->type
= DCB_CONNECTOR_VGA
;
1288 if (encoders
& (1 << DCB_OUTPUT_LVDS
)) {
1289 nv_connector
->type
= DCB_CONNECTOR_LVDS
;
1291 if (encoders
& (1 << DCB_OUTPUT_TV
)) {
1292 nv_connector
->type
= DCB_CONNECTOR_TV_0
;
1296 switch ((type
= drm_conntype_from_dcb(nv_connector
->type
))) {
1297 case DRM_MODE_CONNECTOR_LVDS
:
1298 ret
= nouveau_bios_parse_lvds_table(dev
, 0, &dummy
, &dummy
);
1300 NV_ERROR(drm
, "Error parsing LVDS table, disabling\n");
1301 kfree(nv_connector
);
1302 return ERR_PTR(ret
);
1305 funcs
= &nouveau_connector_funcs_lvds
;
1307 case DRM_MODE_CONNECTOR_DisplayPort
:
1308 case DRM_MODE_CONNECTOR_eDP
:
1309 nv_connector
->aux
.dev
= dev
->dev
;
1310 nv_connector
->aux
.transfer
= nouveau_connector_aux_xfer
;
1311 ret
= drm_dp_aux_register(&nv_connector
->aux
);
1313 NV_ERROR(drm
, "failed to register aux channel\n");
1314 kfree(nv_connector
);
1315 return ERR_PTR(ret
);
1318 funcs
= &nouveau_connector_funcs
;
1321 funcs
= &nouveau_connector_funcs
;
1325 /* HDMI 3D support */
1326 if ((disp
->disp
.oclass
>= G82_DISP
)
1327 && ((type
== DRM_MODE_CONNECTOR_DisplayPort
)
1328 || (type
== DRM_MODE_CONNECTOR_eDP
)
1329 || (type
== DRM_MODE_CONNECTOR_HDMIA
)))
1330 connector
->stereo_allowed
= true;
1332 /* defaults, will get overridden in detect() */
1333 connector
->interlace_allowed
= false;
1334 connector
->doublescan_allowed
= false;
1336 drm_connector_init(dev
, connector
, funcs
, type
);
1337 drm_connector_helper_add(connector
, &nouveau_connector_helper_funcs
);
1339 connector
->funcs
->reset(connector
);
1340 nouveau_conn_attach_properties(connector
);
1342 /* Default scaling mode */
1343 switch (nv_connector
->type
) {
1344 case DCB_CONNECTOR_LVDS
:
1345 case DCB_CONNECTOR_LVDS_SPWG
:
1346 case DCB_CONNECTOR_eDP
:
1347 /* see note in nouveau_connector_set_property() */
1348 if (disp
->disp
.oclass
< NV50_DISP
) {
1349 nv_connector
->scaling_mode
= DRM_MODE_SCALE_FULLSCREEN
;
1352 nv_connector
->scaling_mode
= DRM_MODE_SCALE_NONE
;
1355 nv_connector
->scaling_mode
= DRM_MODE_SCALE_NONE
;
1359 /* dithering properties */
1360 switch (nv_connector
->type
) {
1361 case DCB_CONNECTOR_TV_0
:
1362 case DCB_CONNECTOR_TV_1
:
1363 case DCB_CONNECTOR_TV_3
:
1364 case DCB_CONNECTOR_VGA
:
1367 nv_connector
->dithering_mode
= DITHERING_MODE_AUTO
;
1371 ret
= nvif_notify_init(&disp
->disp
, nouveau_connector_hotplug
, true,
1372 NV04_DISP_NTFY_CONN
,
1373 &(struct nvif_notify_conn_req_v0
) {
1374 .mask
= NVIF_NOTIFY_CONN_V0_ANY
,
1377 sizeof(struct nvif_notify_conn_req_v0
),
1378 sizeof(struct nvif_notify_conn_rep_v0
),
1379 &nv_connector
->hpd
);
1381 connector
->polled
= DRM_CONNECTOR_POLL_CONNECT
;
1383 connector
->polled
= DRM_CONNECTOR_POLL_HPD
;
1385 drm_connector_register(connector
);