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>
31 #include "drm_crtc_helper.h"
33 #include "nouveau_reg.h"
34 #include "nouveau_drv.h"
35 #include "nouveau_encoder.h"
36 #include "nouveau_crtc.h"
37 #include "nouveau_connector.h"
38 #include "nouveau_hw.h"
40 static inline struct drm_encoder_slave_funcs
*
41 get_slave_funcs(struct nouveau_encoder
*enc
)
43 return to_encoder_slave(to_drm_encoder(enc
))->slave_funcs
;
46 static struct nouveau_encoder
*
47 find_encoder_by_type(struct drm_connector
*connector
, int type
)
49 struct drm_device
*dev
= connector
->dev
;
50 struct nouveau_encoder
*nv_encoder
;
51 struct drm_mode_object
*obj
;
54 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
55 id
= connector
->encoder_ids
[i
];
59 obj
= drm_mode_object_find(dev
, id
, DRM_MODE_OBJECT_ENCODER
);
62 nv_encoder
= nouveau_encoder(obj_to_encoder(obj
));
64 if (type
== OUTPUT_ANY
|| nv_encoder
->dcb
->type
== type
)
71 struct nouveau_connector
*
72 nouveau_encoder_connector_get(struct nouveau_encoder
*encoder
)
74 struct drm_device
*dev
= to_drm_encoder(encoder
)->dev
;
75 struct drm_connector
*drm_connector
;
77 list_for_each_entry(drm_connector
, &dev
->mode_config
.connector_list
, head
) {
78 if (drm_connector
->encoder
== to_drm_encoder(encoder
))
79 return nouveau_connector(drm_connector
);
87 nouveau_connector_destroy(struct drm_connector
*drm_connector
)
89 struct nouveau_connector
*nv_connector
=
90 nouveau_connector(drm_connector
);
91 struct drm_device
*dev
;
96 dev
= nv_connector
->base
.dev
;
97 NV_DEBUG_KMS(dev
, "\n");
99 kfree(nv_connector
->edid
);
100 drm_sysfs_connector_remove(drm_connector
);
101 drm_connector_cleanup(drm_connector
);
102 kfree(drm_connector
);
106 nouveau_connector_ddc_prepare(struct drm_connector
*connector
, int *flags
)
108 struct drm_nouveau_private
*dev_priv
= connector
->dev
->dev_private
;
110 if (dev_priv
->card_type
>= NV_50
)
114 if (NVLockVgaCrtcs(dev_priv
->dev
, false))
116 if (nv_heads_tied(dev_priv
->dev
))
120 NVSetOwner(dev_priv
->dev
, 0); /* necessary? */
124 nouveau_connector_ddc_finish(struct drm_connector
*connector
, int flags
)
126 struct drm_nouveau_private
*dev_priv
= connector
->dev
->dev_private
;
128 if (dev_priv
->card_type
>= NV_50
)
132 NVSetOwner(dev_priv
->dev
, 4);
134 NVLockVgaCrtcs(dev_priv
->dev
, true);
137 static struct nouveau_i2c_chan
*
138 nouveau_connector_ddc_detect(struct drm_connector
*connector
,
139 struct nouveau_encoder
**pnv_encoder
)
141 struct drm_device
*dev
= connector
->dev
;
142 uint8_t out_buf
[] = { 0x0, 0x0}, buf
[2];
145 struct i2c_msg msgs
[] = {
160 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
161 struct nouveau_i2c_chan
*i2c
= NULL
;
162 struct nouveau_encoder
*nv_encoder
;
163 struct drm_mode_object
*obj
;
166 id
= connector
->encoder_ids
[i
];
170 obj
= drm_mode_object_find(dev
, id
, DRM_MODE_OBJECT_ENCODER
);
173 nv_encoder
= nouveau_encoder(obj_to_encoder(obj
));
175 if (nv_encoder
->dcb
->i2c_index
< 0xf)
176 i2c
= nouveau_i2c_find(dev
, nv_encoder
->dcb
->i2c_index
);
180 nouveau_connector_ddc_prepare(connector
, &flags
);
181 ret
= i2c_transfer(&i2c
->adapter
, msgs
, 2);
182 nouveau_connector_ddc_finish(connector
, flags
);
185 *pnv_encoder
= nv_encoder
;
194 nouveau_connector_set_encoder(struct drm_connector
*connector
,
195 struct nouveau_encoder
*nv_encoder
)
197 struct nouveau_connector
*nv_connector
= nouveau_connector(connector
);
198 struct drm_nouveau_private
*dev_priv
= connector
->dev
->dev_private
;
199 struct drm_device
*dev
= connector
->dev
;
201 if (nv_connector
->detected_encoder
== nv_encoder
)
203 nv_connector
->detected_encoder
= nv_encoder
;
205 if (nv_encoder
->dcb
->type
== OUTPUT_LVDS
||
206 nv_encoder
->dcb
->type
== OUTPUT_TMDS
) {
207 connector
->doublescan_allowed
= false;
208 connector
->interlace_allowed
= false;
210 connector
->doublescan_allowed
= true;
211 if (dev_priv
->card_type
== NV_20
||
212 (dev_priv
->card_type
== NV_10
&&
213 (dev
->pci_device
& 0x0ff0) != 0x0100 &&
214 (dev
->pci_device
& 0x0ff0) != 0x0150))
216 connector
->interlace_allowed
= false;
218 connector
->interlace_allowed
= true;
221 if (connector
->connector_type
== DRM_MODE_CONNECTOR_DVII
) {
222 drm_connector_property_set_value(connector
,
223 dev
->mode_config
.dvi_i_subconnector_property
,
224 nv_encoder
->dcb
->type
== OUTPUT_TMDS
?
225 DRM_MODE_SUBCONNECTOR_DVID
:
226 DRM_MODE_SUBCONNECTOR_DVIA
);
230 static enum drm_connector_status
231 nouveau_connector_detect(struct drm_connector
*connector
)
233 struct drm_device
*dev
= connector
->dev
;
234 struct nouveau_connector
*nv_connector
= nouveau_connector(connector
);
235 struct nouveau_encoder
*nv_encoder
= NULL
;
236 struct nouveau_i2c_chan
*i2c
;
239 if (connector
->connector_type
== DRM_MODE_CONNECTOR_LVDS
)
240 nv_encoder
= find_encoder_by_type(connector
, OUTPUT_LVDS
);
241 if (nv_encoder
&& nv_connector
->native_mode
) {
243 if (!nouveau_ignorelid
&& !acpi_lid_open())
244 return connector_status_disconnected
;
246 nouveau_connector_set_encoder(connector
, nv_encoder
);
247 return connector_status_connected
;
250 /* Cleanup the previous EDID block. */
251 if (nv_connector
->edid
) {
252 drm_mode_connector_update_edid_property(connector
, NULL
);
253 kfree(nv_connector
->edid
);
254 nv_connector
->edid
= NULL
;
257 i2c
= nouveau_connector_ddc_detect(connector
, &nv_encoder
);
259 nouveau_connector_ddc_prepare(connector
, &flags
);
260 nv_connector
->edid
= drm_get_edid(connector
, &i2c
->adapter
);
261 nouveau_connector_ddc_finish(connector
, flags
);
262 drm_mode_connector_update_edid_property(connector
,
264 if (!nv_connector
->edid
) {
265 NV_ERROR(dev
, "DDC responded, but no EDID for %s\n",
266 drm_get_connector_name(connector
));
270 if (nv_encoder
->dcb
->type
== OUTPUT_DP
&&
271 !nouveau_dp_detect(to_drm_encoder(nv_encoder
))) {
272 NV_ERROR(dev
, "Detected %s, but failed init\n",
273 drm_get_connector_name(connector
));
274 return connector_status_disconnected
;
277 /* Override encoder type for DVI-I based on whether EDID
278 * says the display is digital or analog, both use the
279 * same i2c channel so the value returned from ddc_detect
280 * isn't necessarily correct.
282 if (connector
->connector_type
== DRM_MODE_CONNECTOR_DVII
) {
283 if (nv_connector
->edid
->input
& DRM_EDID_INPUT_DIGITAL
)
286 type
= OUTPUT_ANALOG
;
288 nv_encoder
= find_encoder_by_type(connector
, type
);
290 NV_ERROR(dev
, "Detected %d encoder on %s, "
291 "but no object!\n", type
,
292 drm_get_connector_name(connector
));
293 return connector_status_disconnected
;
297 nouveau_connector_set_encoder(connector
, nv_encoder
);
298 return connector_status_connected
;
302 nv_encoder
= find_encoder_by_type(connector
, OUTPUT_ANALOG
);
304 nv_encoder
= find_encoder_by_type(connector
, OUTPUT_TV
);
306 struct drm_encoder
*encoder
= to_drm_encoder(nv_encoder
);
307 struct drm_encoder_helper_funcs
*helper
=
308 encoder
->helper_private
;
310 if (helper
->detect(encoder
, connector
) ==
311 connector_status_connected
) {
312 nouveau_connector_set_encoder(connector
, nv_encoder
);
313 return connector_status_connected
;
318 return connector_status_disconnected
;
322 nouveau_connector_force(struct drm_connector
*connector
)
324 struct drm_device
*dev
= connector
->dev
;
325 struct nouveau_encoder
*nv_encoder
;
328 if (connector
->connector_type
== DRM_MODE_CONNECTOR_DVII
) {
329 if (connector
->force
== DRM_FORCE_ON_DIGITAL
)
332 type
= OUTPUT_ANALOG
;
336 nv_encoder
= find_encoder_by_type(connector
, type
);
338 NV_ERROR(dev
, "can't find encoder to force %s on!\n",
339 drm_get_connector_name(connector
));
340 connector
->status
= connector_status_disconnected
;
344 nouveau_connector_set_encoder(connector
, nv_encoder
);
348 nouveau_connector_set_property(struct drm_connector
*connector
,
349 struct drm_property
*property
, uint64_t value
)
351 struct nouveau_connector
*nv_connector
= nouveau_connector(connector
);
352 struct nouveau_encoder
*nv_encoder
= nv_connector
->detected_encoder
;
353 struct drm_device
*dev
= connector
->dev
;
357 if (property
== dev
->mode_config
.scaling_mode_property
) {
358 struct nouveau_crtc
*nv_crtc
= NULL
;
359 bool modeset
= false;
362 case DRM_MODE_SCALE_NONE
:
363 case DRM_MODE_SCALE_FULLSCREEN
:
364 case DRM_MODE_SCALE_CENTER
:
365 case DRM_MODE_SCALE_ASPECT
:
371 /* LVDS always needs gpu scaling */
372 if (connector
->connector_type
== DRM_MODE_CONNECTOR_LVDS
&&
373 value
== DRM_MODE_SCALE_NONE
)
376 /* Changing between GPU and panel scaling requires a full
379 if ((nv_connector
->scaling_mode
== DRM_MODE_SCALE_NONE
) ||
380 (value
== DRM_MODE_SCALE_NONE
))
382 nv_connector
->scaling_mode
= value
;
384 if (connector
->encoder
&& connector
->encoder
->crtc
)
385 nv_crtc
= nouveau_crtc(connector
->encoder
->crtc
);
389 if (modeset
|| !nv_crtc
->set_scale
) {
390 ret
= drm_crtc_helper_set_mode(&nv_crtc
->base
,
393 nv_crtc
->base
.y
, NULL
);
397 ret
= nv_crtc
->set_scale(nv_crtc
, value
, true);
406 if (property
== dev
->mode_config
.dithering_mode_property
) {
407 struct nouveau_crtc
*nv_crtc
= NULL
;
409 if (value
== DRM_MODE_DITHERING_ON
)
410 nv_connector
->use_dithering
= true;
412 nv_connector
->use_dithering
= false;
414 if (connector
->encoder
&& connector
->encoder
->crtc
)
415 nv_crtc
= nouveau_crtc(connector
->encoder
->crtc
);
417 if (!nv_crtc
|| !nv_crtc
->set_dither
)
420 return nv_crtc
->set_dither(nv_crtc
, nv_connector
->use_dithering
,
424 if (nv_encoder
&& nv_encoder
->dcb
->type
== OUTPUT_TV
)
425 return get_slave_funcs(nv_encoder
)->
426 set_property(to_drm_encoder(nv_encoder
), connector
, property
, value
);
431 static struct drm_display_mode
*
432 nouveau_connector_native_mode(struct nouveau_connector
*connector
)
434 struct drm_device
*dev
= connector
->base
.dev
;
435 struct drm_display_mode
*mode
, *largest
= NULL
;
436 int high_w
= 0, high_h
= 0, high_v
= 0;
438 /* Use preferred mode if there is one.. */
439 list_for_each_entry(mode
, &connector
->base
.probed_modes
, head
) {
440 if (mode
->type
& DRM_MODE_TYPE_PREFERRED
) {
441 NV_DEBUG_KMS(dev
, "native mode from preferred\n");
442 return drm_mode_duplicate(dev
, mode
);
446 /* Otherwise, take the resolution with the largest width, then height,
447 * then vertical refresh
449 list_for_each_entry(mode
, &connector
->base
.probed_modes
, head
) {
450 if (mode
->hdisplay
< high_w
)
453 if (mode
->hdisplay
== high_w
&& mode
->vdisplay
< high_h
)
456 if (mode
->hdisplay
== high_w
&& mode
->vdisplay
== high_h
&&
457 mode
->vrefresh
< high_v
)
460 high_w
= mode
->hdisplay
;
461 high_h
= mode
->vdisplay
;
462 high_v
= mode
->vrefresh
;
466 NV_DEBUG_KMS(dev
, "native mode from largest: %dx%d@%d\n",
467 high_w
, high_h
, high_v
);
468 return largest
? drm_mode_duplicate(dev
, largest
) : NULL
;
476 static struct moderec scaler_modes
[] = {
495 nouveau_connector_scaler_modes_add(struct drm_connector
*connector
)
497 struct nouveau_connector
*nv_connector
= nouveau_connector(connector
);
498 struct drm_display_mode
*native
= nv_connector
->native_mode
, *m
;
499 struct drm_device
*dev
= connector
->dev
;
500 struct moderec
*mode
= &scaler_modes
[0];
506 while (mode
->hdisplay
) {
507 if (mode
->hdisplay
<= native
->hdisplay
&&
508 mode
->vdisplay
<= native
->vdisplay
) {
509 m
= drm_cvt_mode(dev
, mode
->hdisplay
, mode
->vdisplay
,
510 drm_mode_vrefresh(native
), false,
515 m
->type
|= DRM_MODE_TYPE_DRIVER
;
517 drm_mode_probed_add(connector
, m
);
528 nouveau_connector_get_modes(struct drm_connector
*connector
)
530 struct drm_device
*dev
= connector
->dev
;
531 struct nouveau_connector
*nv_connector
= nouveau_connector(connector
);
532 struct nouveau_encoder
*nv_encoder
= nv_connector
->detected_encoder
;
535 /* If we're not LVDS, destroy the previous native mode, the attached
536 * monitor could have changed.
538 if (connector
->connector_type
!= DRM_MODE_CONNECTOR_LVDS
&&
539 nv_connector
->native_mode
) {
540 drm_mode_destroy(dev
, nv_connector
->native_mode
);
541 nv_connector
->native_mode
= NULL
;
544 if (nv_connector
->edid
)
545 ret
= drm_add_edid_modes(connector
, nv_connector
->edid
);
547 /* Find the native mode if this is a digital panel, if we didn't
548 * find any modes through DDC previously add the native mode to
551 if (!nv_connector
->native_mode
)
552 nv_connector
->native_mode
=
553 nouveau_connector_native_mode(nv_connector
);
554 if (ret
== 0 && nv_connector
->native_mode
) {
555 struct drm_display_mode
*mode
;
557 mode
= drm_mode_duplicate(dev
, nv_connector
->native_mode
);
558 drm_mode_probed_add(connector
, mode
);
562 if (nv_encoder
->dcb
->type
== OUTPUT_TV
)
563 ret
= get_slave_funcs(nv_encoder
)->
564 get_modes(to_drm_encoder(nv_encoder
), connector
);
566 if (connector
->connector_type
== DRM_MODE_CONNECTOR_LVDS
)
567 ret
+= nouveau_connector_scaler_modes_add(connector
);
573 nouveau_connector_mode_valid(struct drm_connector
*connector
,
574 struct drm_display_mode
*mode
)
576 struct drm_nouveau_private
*dev_priv
= connector
->dev
->dev_private
;
577 struct nouveau_connector
*nv_connector
= nouveau_connector(connector
);
578 struct nouveau_encoder
*nv_encoder
= nv_connector
->detected_encoder
;
579 unsigned min_clock
= 25000, max_clock
= min_clock
;
580 unsigned clock
= mode
->clock
;
582 switch (nv_encoder
->dcb
->type
) {
584 BUG_ON(!nv_connector
->native_mode
);
585 if (mode
->hdisplay
> nv_connector
->native_mode
->hdisplay
||
586 mode
->vdisplay
> nv_connector
->native_mode
->vdisplay
)
593 if ((dev_priv
->card_type
>= NV_50
&& !nouveau_duallink
) ||
594 (dev_priv
->card_type
< NV_50
&&
595 !nv_encoder
->dcb
->duallink_possible
))
601 max_clock
= nv_encoder
->dcb
->crtconf
.maxfreq
;
606 return get_slave_funcs(nv_encoder
)->
607 mode_valid(to_drm_encoder(nv_encoder
), mode
);
609 if (nv_encoder
->dp
.link_bw
== DP_LINK_BW_2_7
)
610 max_clock
= nv_encoder
->dp
.link_nr
* 270000;
612 max_clock
= nv_encoder
->dp
.link_nr
* 162000;
618 if (clock
< min_clock
)
619 return MODE_CLOCK_LOW
;
621 if (clock
> max_clock
)
622 return MODE_CLOCK_HIGH
;
627 static struct drm_encoder
*
628 nouveau_connector_best_encoder(struct drm_connector
*connector
)
630 struct nouveau_connector
*nv_connector
= nouveau_connector(connector
);
632 if (nv_connector
->detected_encoder
)
633 return to_drm_encoder(nv_connector
->detected_encoder
);
638 static const struct drm_connector_helper_funcs
639 nouveau_connector_helper_funcs
= {
640 .get_modes
= nouveau_connector_get_modes
,
641 .mode_valid
= nouveau_connector_mode_valid
,
642 .best_encoder
= nouveau_connector_best_encoder
,
645 static const struct drm_connector_funcs
646 nouveau_connector_funcs
= {
647 .dpms
= drm_helper_connector_dpms
,
650 .detect
= nouveau_connector_detect
,
651 .destroy
= nouveau_connector_destroy
,
652 .fill_modes
= drm_helper_probe_single_connector_modes
,
653 .set_property
= nouveau_connector_set_property
,
654 .force
= nouveau_connector_force
658 nouveau_connector_create_lvds(struct drm_device
*dev
,
659 struct drm_connector
*connector
)
661 struct nouveau_connector
*nv_connector
= nouveau_connector(connector
);
662 struct drm_nouveau_private
*dev_priv
= dev
->dev_private
;
663 struct nouveau_i2c_chan
*i2c
= NULL
;
664 struct nouveau_encoder
*nv_encoder
;
665 struct drm_display_mode native
, *mode
, *temp
;
666 bool dummy
, if_is_24bit
= false;
669 nv_encoder
= find_encoder_by_type(connector
, OUTPUT_LVDS
);
673 ret
= nouveau_bios_parse_lvds_table(dev
, 0, &dummy
, &if_is_24bit
);
675 NV_ERROR(dev
, "Error parsing LVDS table, disabling LVDS\n");
678 nv_connector
->use_dithering
= !if_is_24bit
;
680 /* Firstly try getting EDID over DDC, if allowed and I2C channel
683 if (!dev_priv
->VBIOS
.pub
.fp_no_ddc
&& nv_encoder
->dcb
->i2c_index
< 0xf)
684 i2c
= nouveau_i2c_find(dev
, nv_encoder
->dcb
->i2c_index
);
687 nouveau_connector_ddc_prepare(connector
, &flags
);
688 nv_connector
->edid
= drm_get_edid(connector
, &i2c
->adapter
);
689 nouveau_connector_ddc_finish(connector
, flags
);
692 /* If no EDID found above, and the VBIOS indicates a hardcoded
693 * modeline is avalilable for the panel, set it as the panel's
694 * native mode and exit.
696 if (!nv_connector
->edid
&& nouveau_bios_fp_mode(dev
, &native
) &&
697 (nv_encoder
->dcb
->lvdsconf
.use_straps_for_mode
||
698 dev_priv
->VBIOS
.pub
.fp_no_ddc
)) {
699 nv_connector
->native_mode
= drm_mode_duplicate(dev
, &native
);
703 /* Still nothing, some VBIOS images have a hardcoded EDID block
704 * stored for the panel stored in them.
706 if (!nv_connector
->edid
&& !nv_connector
->native_mode
&&
707 !dev_priv
->VBIOS
.pub
.fp_no_ddc
) {
709 (struct edid
*)nouveau_bios_embedded_edid(dev
);
711 nv_connector
->edid
= kmalloc(EDID_LENGTH
, GFP_KERNEL
);
712 *(nv_connector
->edid
) = *edid
;
716 if (!nv_connector
->edid
)
719 /* We didn't find/use a panel mode from the VBIOS, so parse the EDID
720 * block and look for the preferred mode there.
722 ret
= drm_add_edid_modes(connector
, nv_connector
->edid
);
725 nv_connector
->detected_encoder
= nv_encoder
;
726 nv_connector
->native_mode
= nouveau_connector_native_mode(nv_connector
);
727 list_for_each_entry_safe(mode
, temp
, &connector
->probed_modes
, head
)
728 drm_mode_remove(connector
, mode
);
731 if (!nv_connector
->native_mode
) {
732 NV_ERROR(dev
, "LVDS present in DCB table, but couldn't "
733 "determine its native mode. Disabling.\n");
737 drm_mode_connector_update_edid_property(connector
, nv_connector
->edid
);
742 nouveau_connector_create(struct drm_device
*dev
, int index
, int type
)
744 struct drm_nouveau_private
*dev_priv
= dev
->dev_private
;
745 struct nouveau_connector
*nv_connector
= NULL
;
746 struct drm_connector
*connector
;
747 struct drm_encoder
*encoder
;
750 NV_DEBUG_KMS(dev
, "\n");
752 nv_connector
= kzalloc(sizeof(*nv_connector
), GFP_KERNEL
);
755 nv_connector
->dcb
= nouveau_bios_connector_entry(dev
, index
);
756 connector
= &nv_connector
->base
;
759 case DRM_MODE_CONNECTOR_VGA
:
760 NV_INFO(dev
, "Detected a VGA connector\n");
762 case DRM_MODE_CONNECTOR_DVID
:
763 NV_INFO(dev
, "Detected a DVI-D connector\n");
765 case DRM_MODE_CONNECTOR_DVII
:
766 NV_INFO(dev
, "Detected a DVI-I connector\n");
768 case DRM_MODE_CONNECTOR_LVDS
:
769 NV_INFO(dev
, "Detected a LVDS connector\n");
771 case DRM_MODE_CONNECTOR_TV
:
772 NV_INFO(dev
, "Detected a TV connector\n");
774 case DRM_MODE_CONNECTOR_DisplayPort
:
775 NV_INFO(dev
, "Detected a DisplayPort connector\n");
778 NV_ERROR(dev
, "Unknown connector, this is not good.\n");
782 /* defaults, will get overridden in detect() */
783 connector
->interlace_allowed
= false;
784 connector
->doublescan_allowed
= false;
786 drm_connector_init(dev
, connector
, &nouveau_connector_funcs
, type
);
787 drm_connector_helper_add(connector
, &nouveau_connector_helper_funcs
);
789 /* Init DVI-I specific properties */
790 if (type
== DRM_MODE_CONNECTOR_DVII
) {
791 drm_mode_create_dvi_i_properties(dev
);
792 drm_connector_attach_property(connector
, dev
->mode_config
.dvi_i_subconnector_property
, 0);
793 drm_connector_attach_property(connector
, dev
->mode_config
.dvi_i_select_subconnector_property
, 0);
796 if (type
!= DRM_MODE_CONNECTOR_LVDS
)
797 nv_connector
->use_dithering
= false;
799 if (type
== DRM_MODE_CONNECTOR_DVID
||
800 type
== DRM_MODE_CONNECTOR_DVII
||
801 type
== DRM_MODE_CONNECTOR_LVDS
||
802 type
== DRM_MODE_CONNECTOR_DisplayPort
) {
803 nv_connector
->scaling_mode
= DRM_MODE_SCALE_FULLSCREEN
;
805 drm_connector_attach_property(connector
, dev
->mode_config
.scaling_mode_property
,
806 nv_connector
->scaling_mode
);
807 drm_connector_attach_property(connector
, dev
->mode_config
.dithering_mode_property
,
808 nv_connector
->use_dithering
? DRM_MODE_DITHERING_ON
809 : DRM_MODE_DITHERING_OFF
);
812 nv_connector
->scaling_mode
= DRM_MODE_SCALE_NONE
;
814 if (type
== DRM_MODE_CONNECTOR_VGA
&&
815 dev_priv
->card_type
>= NV_50
) {
816 drm_connector_attach_property(connector
,
817 dev
->mode_config
.scaling_mode_property
,
818 nv_connector
->scaling_mode
);
822 /* attach encoders */
823 list_for_each_entry(encoder
, &dev
->mode_config
.encoder_list
, head
) {
824 struct nouveau_encoder
*nv_encoder
= nouveau_encoder(encoder
);
826 if (nv_encoder
->dcb
->connector
!= index
)
829 if (get_slave_funcs(nv_encoder
))
830 get_slave_funcs(nv_encoder
)->create_resources(encoder
, connector
);
832 drm_mode_connector_attach_encoder(connector
, encoder
);
835 drm_sysfs_connector_add(connector
);
837 if (connector
->connector_type
== DRM_MODE_CONNECTOR_LVDS
) {
838 ret
= nouveau_connector_create_lvds(dev
, connector
);
840 connector
->funcs
->destroy(connector
);