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 struct nouveau_encoder
*
41 find_encoder_by_type(struct drm_connector
*connector
, int type
)
43 struct drm_device
*dev
= connector
->dev
;
44 struct nouveau_encoder
*nv_encoder
;
45 struct drm_mode_object
*obj
;
48 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
49 id
= connector
->encoder_ids
[i
];
53 obj
= drm_mode_object_find(dev
, id
, DRM_MODE_OBJECT_ENCODER
);
56 nv_encoder
= nouveau_encoder(obj_to_encoder(obj
));
58 if (type
== OUTPUT_ANY
|| nv_encoder
->dcb
->type
== type
)
65 struct nouveau_connector
*
66 nouveau_encoder_connector_get(struct nouveau_encoder
*encoder
)
68 struct drm_device
*dev
= to_drm_encoder(encoder
)->dev
;
69 struct drm_connector
*drm_connector
;
71 list_for_each_entry(drm_connector
, &dev
->mode_config
.connector_list
, head
) {
72 if (drm_connector
->encoder
== to_drm_encoder(encoder
))
73 return nouveau_connector(drm_connector
);
79 /*TODO: This could use improvement, and learn to handle the fixed
80 * BIOS tables etc. It's fine currently, for its only user.
83 nouveau_connector_bpp(struct drm_connector
*connector
)
85 struct nouveau_connector
*nv_connector
= nouveau_connector(connector
);
87 if (nv_connector
->edid
&& nv_connector
->edid
->revision
>= 4) {
88 u8 bpc
= ((nv_connector
->edid
->input
& 0x70) >> 3) + 4;
97 nouveau_connector_destroy(struct drm_connector
*drm_connector
)
99 struct nouveau_connector
*nv_connector
=
100 nouveau_connector(drm_connector
);
101 struct drm_device
*dev
;
106 dev
= nv_connector
->base
.dev
;
107 NV_DEBUG_KMS(dev
, "\n");
109 kfree(nv_connector
->edid
);
110 drm_sysfs_connector_remove(drm_connector
);
111 drm_connector_cleanup(drm_connector
);
112 kfree(drm_connector
);
115 static struct nouveau_i2c_chan
*
116 nouveau_connector_ddc_detect(struct drm_connector
*connector
,
117 struct nouveau_encoder
**pnv_encoder
)
119 struct drm_device
*dev
= connector
->dev
;
122 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
123 struct nouveau_i2c_chan
*i2c
= NULL
;
124 struct nouveau_encoder
*nv_encoder
;
125 struct drm_mode_object
*obj
;
128 id
= connector
->encoder_ids
[i
];
132 obj
= drm_mode_object_find(dev
, id
, DRM_MODE_OBJECT_ENCODER
);
135 nv_encoder
= nouveau_encoder(obj_to_encoder(obj
));
137 if (nv_encoder
->dcb
->i2c_index
< 0xf)
138 i2c
= nouveau_i2c_find(dev
, nv_encoder
->dcb
->i2c_index
);
140 if (i2c
&& nouveau_probe_i2c_addr(i2c
, 0x50)) {
141 *pnv_encoder
= nv_encoder
;
149 static struct nouveau_encoder
*
150 nouveau_connector_of_detect(struct drm_connector
*connector
)
153 struct drm_device
*dev
= connector
->dev
;
154 struct nouveau_connector
*nv_connector
= nouveau_connector(connector
);
155 struct nouveau_encoder
*nv_encoder
;
156 struct device_node
*cn
, *dn
= pci_device_to_OF_node(dev
->pdev
);
159 !((nv_encoder
= find_encoder_by_type(connector
, OUTPUT_TMDS
)) ||
160 (nv_encoder
= find_encoder_by_type(connector
, OUTPUT_ANALOG
))))
163 for_each_child_of_node(dn
, cn
) {
164 const char *name
= of_get_property(cn
, "name", NULL
);
165 const void *edid
= of_get_property(cn
, "EDID", NULL
);
166 int idx
= name
? name
[strlen(name
) - 1] - 'A' : 0;
168 if (nv_encoder
->dcb
->i2c_index
== idx
&& edid
) {
170 kmemdup(edid
, EDID_LENGTH
, GFP_KERNEL
);
180 nouveau_connector_set_encoder(struct drm_connector
*connector
,
181 struct nouveau_encoder
*nv_encoder
)
183 struct nouveau_connector
*nv_connector
= nouveau_connector(connector
);
184 struct drm_nouveau_private
*dev_priv
= connector
->dev
->dev_private
;
185 struct drm_device
*dev
= connector
->dev
;
187 if (nv_connector
->detected_encoder
== nv_encoder
)
189 nv_connector
->detected_encoder
= nv_encoder
;
191 if (nv_encoder
->dcb
->type
== OUTPUT_LVDS
||
192 nv_encoder
->dcb
->type
== OUTPUT_TMDS
) {
193 connector
->doublescan_allowed
= false;
194 connector
->interlace_allowed
= false;
196 connector
->doublescan_allowed
= true;
197 if (dev_priv
->card_type
== NV_20
||
198 (dev_priv
->card_type
== NV_10
&&
199 (dev
->pci_device
& 0x0ff0) != 0x0100 &&
200 (dev
->pci_device
& 0x0ff0) != 0x0150))
202 connector
->interlace_allowed
= false;
204 connector
->interlace_allowed
= true;
207 if (nv_connector
->dcb
->type
== DCB_CONNECTOR_DVI_I
) {
208 drm_connector_property_set_value(connector
,
209 dev
->mode_config
.dvi_i_subconnector_property
,
210 nv_encoder
->dcb
->type
== OUTPUT_TMDS
?
211 DRM_MODE_SUBCONNECTOR_DVID
:
212 DRM_MODE_SUBCONNECTOR_DVIA
);
216 static enum drm_connector_status
217 nouveau_connector_detect(struct drm_connector
*connector
, bool force
)
219 struct drm_device
*dev
= connector
->dev
;
220 struct nouveau_connector
*nv_connector
= nouveau_connector(connector
);
221 struct nouveau_encoder
*nv_encoder
= NULL
;
222 struct nouveau_i2c_chan
*i2c
;
225 /* Cleanup the previous EDID block. */
226 if (nv_connector
->edid
) {
227 drm_mode_connector_update_edid_property(connector
, NULL
);
228 kfree(nv_connector
->edid
);
229 nv_connector
->edid
= NULL
;
232 i2c
= nouveau_connector_ddc_detect(connector
, &nv_encoder
);
234 nv_connector
->edid
= drm_get_edid(connector
, &i2c
->adapter
);
235 drm_mode_connector_update_edid_property(connector
,
237 if (!nv_connector
->edid
) {
238 NV_ERROR(dev
, "DDC responded, but no EDID for %s\n",
239 drm_get_connector_name(connector
));
243 if (nv_encoder
->dcb
->type
== OUTPUT_DP
&&
244 !nouveau_dp_detect(to_drm_encoder(nv_encoder
))) {
245 NV_ERROR(dev
, "Detected %s, but failed init\n",
246 drm_get_connector_name(connector
));
247 return connector_status_disconnected
;
250 /* Override encoder type for DVI-I based on whether EDID
251 * says the display is digital or analog, both use the
252 * same i2c channel so the value returned from ddc_detect
253 * isn't necessarily correct.
255 if (nv_connector
->dcb
->type
== DCB_CONNECTOR_DVI_I
) {
256 if (nv_connector
->edid
->input
& DRM_EDID_INPUT_DIGITAL
)
259 type
= OUTPUT_ANALOG
;
261 nv_encoder
= find_encoder_by_type(connector
, type
);
263 NV_ERROR(dev
, "Detected %d encoder on %s, "
264 "but no object!\n", type
,
265 drm_get_connector_name(connector
));
266 return connector_status_disconnected
;
270 nouveau_connector_set_encoder(connector
, nv_encoder
);
271 return connector_status_connected
;
274 nv_encoder
= nouveau_connector_of_detect(connector
);
276 nouveau_connector_set_encoder(connector
, nv_encoder
);
277 return connector_status_connected
;
281 nv_encoder
= find_encoder_by_type(connector
, OUTPUT_ANALOG
);
282 if (!nv_encoder
&& !nouveau_tv_disable
)
283 nv_encoder
= find_encoder_by_type(connector
, OUTPUT_TV
);
285 struct drm_encoder
*encoder
= to_drm_encoder(nv_encoder
);
286 struct drm_encoder_helper_funcs
*helper
=
287 encoder
->helper_private
;
289 if (helper
->detect(encoder
, connector
) ==
290 connector_status_connected
) {
291 nouveau_connector_set_encoder(connector
, nv_encoder
);
292 return connector_status_connected
;
297 return connector_status_disconnected
;
300 static enum drm_connector_status
301 nouveau_connector_detect_lvds(struct drm_connector
*connector
, bool force
)
303 struct drm_device
*dev
= connector
->dev
;
304 struct drm_nouveau_private
*dev_priv
= dev
->dev_private
;
305 struct nouveau_connector
*nv_connector
= nouveau_connector(connector
);
306 struct nouveau_encoder
*nv_encoder
= NULL
;
307 enum drm_connector_status status
= connector_status_disconnected
;
309 /* Cleanup the previous EDID block. */
310 if (nv_connector
->edid
) {
311 drm_mode_connector_update_edid_property(connector
, NULL
);
312 kfree(nv_connector
->edid
);
313 nv_connector
->edid
= NULL
;
316 nv_encoder
= find_encoder_by_type(connector
, OUTPUT_LVDS
);
318 return connector_status_disconnected
;
320 /* Try retrieving EDID via DDC */
321 if (!dev_priv
->vbios
.fp_no_ddc
) {
322 status
= nouveau_connector_detect(connector
, force
);
323 if (status
== connector_status_connected
)
327 /* On some laptops (Sony, i'm looking at you) there appears to
328 * be no direct way of accessing the panel's EDID. The only
329 * option available to us appears to be to ask ACPI for help..
331 * It's important this check's before trying straps, one of the
332 * said manufacturer's laptops are configured in such a way
333 * the nouveau decides an entry in the VBIOS FP mode table is
334 * valid - it's not (rh#613284)
336 if (nv_encoder
->dcb
->lvdsconf
.use_acpi_for_edid
) {
337 if (!nouveau_acpi_edid(dev
, connector
)) {
338 status
= connector_status_connected
;
343 /* If no EDID found above, and the VBIOS indicates a hardcoded
344 * modeline is avalilable for the panel, set it as the panel's
345 * native mode and exit.
347 if (nouveau_bios_fp_mode(dev
, NULL
) && (dev_priv
->vbios
.fp_no_ddc
||
348 nv_encoder
->dcb
->lvdsconf
.use_straps_for_mode
)) {
349 status
= connector_status_connected
;
353 /* Still nothing, some VBIOS images have a hardcoded EDID block
354 * stored for the panel stored in them.
356 if (!dev_priv
->vbios
.fp_no_ddc
) {
358 (struct edid
*)nouveau_bios_embedded_edid(dev
);
360 nv_connector
->edid
= kmalloc(EDID_LENGTH
, GFP_KERNEL
);
361 *(nv_connector
->edid
) = *edid
;
362 status
= connector_status_connected
;
367 #if defined(CONFIG_ACPI_BUTTON) || \
368 (defined(CONFIG_ACPI_BUTTON_MODULE) && defined(MODULE))
369 if (status
== connector_status_connected
&&
370 !nouveau_ignorelid
&& !acpi_lid_open())
371 status
= connector_status_unknown
;
374 drm_mode_connector_update_edid_property(connector
, nv_connector
->edid
);
375 nouveau_connector_set_encoder(connector
, nv_encoder
);
380 nouveau_connector_force(struct drm_connector
*connector
)
382 struct nouveau_connector
*nv_connector
= nouveau_connector(connector
);
383 struct nouveau_encoder
*nv_encoder
;
386 if (nv_connector
->dcb
->type
== DCB_CONNECTOR_DVI_I
) {
387 if (connector
->force
== DRM_FORCE_ON_DIGITAL
)
390 type
= OUTPUT_ANALOG
;
394 nv_encoder
= find_encoder_by_type(connector
, type
);
396 NV_ERROR(connector
->dev
, "can't find encoder to force %s on!\n",
397 drm_get_connector_name(connector
));
398 connector
->status
= connector_status_disconnected
;
402 nouveau_connector_set_encoder(connector
, nv_encoder
);
406 nouveau_connector_set_property(struct drm_connector
*connector
,
407 struct drm_property
*property
, uint64_t value
)
409 struct nouveau_connector
*nv_connector
= nouveau_connector(connector
);
410 struct nouveau_encoder
*nv_encoder
= nv_connector
->detected_encoder
;
411 struct drm_encoder
*encoder
= to_drm_encoder(nv_encoder
);
412 struct drm_device
*dev
= connector
->dev
;
416 if (property
== dev
->mode_config
.scaling_mode_property
) {
417 struct nouveau_crtc
*nv_crtc
= NULL
;
418 bool modeset
= false;
421 case DRM_MODE_SCALE_NONE
:
422 case DRM_MODE_SCALE_FULLSCREEN
:
423 case DRM_MODE_SCALE_CENTER
:
424 case DRM_MODE_SCALE_ASPECT
:
430 /* LVDS always needs gpu scaling */
431 if (nv_connector
->dcb
->type
== DCB_CONNECTOR_LVDS
&&
432 value
== DRM_MODE_SCALE_NONE
)
435 /* Changing between GPU and panel scaling requires a full
438 if ((nv_connector
->scaling_mode
== DRM_MODE_SCALE_NONE
) ||
439 (value
== DRM_MODE_SCALE_NONE
))
441 nv_connector
->scaling_mode
= value
;
443 if (connector
->encoder
&& connector
->encoder
->crtc
)
444 nv_crtc
= nouveau_crtc(connector
->encoder
->crtc
);
448 if (modeset
|| !nv_crtc
->set_scale
) {
449 ret
= drm_crtc_helper_set_mode(&nv_crtc
->base
,
452 nv_crtc
->base
.y
, NULL
);
456 ret
= nv_crtc
->set_scale(nv_crtc
, value
, true);
465 if (property
== dev
->mode_config
.dithering_mode_property
) {
466 struct nouveau_crtc
*nv_crtc
= NULL
;
468 if (value
== DRM_MODE_DITHERING_ON
)
469 nv_connector
->use_dithering
= true;
471 nv_connector
->use_dithering
= false;
473 if (connector
->encoder
&& connector
->encoder
->crtc
)
474 nv_crtc
= nouveau_crtc(connector
->encoder
->crtc
);
476 if (!nv_crtc
|| !nv_crtc
->set_dither
)
479 return nv_crtc
->set_dither(nv_crtc
, nv_connector
->use_dithering
,
483 if (nv_encoder
&& nv_encoder
->dcb
->type
== OUTPUT_TV
)
484 return get_slave_funcs(encoder
)->set_property(
485 encoder
, connector
, property
, value
);
490 static struct drm_display_mode
*
491 nouveau_connector_native_mode(struct drm_connector
*connector
)
493 struct drm_connector_helper_funcs
*helper
= connector
->helper_private
;
494 struct nouveau_connector
*nv_connector
= nouveau_connector(connector
);
495 struct drm_device
*dev
= connector
->dev
;
496 struct drm_display_mode
*mode
, *largest
= NULL
;
497 int high_w
= 0, high_h
= 0, high_v
= 0;
499 list_for_each_entry(mode
, &nv_connector
->base
.probed_modes
, head
) {
500 if (helper
->mode_valid(connector
, mode
) != MODE_OK
||
501 (mode
->flags
& DRM_MODE_FLAG_INTERLACE
))
504 /* Use preferred mode if there is one.. */
505 if (mode
->type
& DRM_MODE_TYPE_PREFERRED
) {
506 NV_DEBUG_KMS(dev
, "native mode from preferred\n");
507 return drm_mode_duplicate(dev
, mode
);
510 /* Otherwise, take the resolution with the largest width, then
511 * height, then vertical refresh
513 if (mode
->hdisplay
< high_w
)
516 if (mode
->hdisplay
== high_w
&& mode
->vdisplay
< high_h
)
519 if (mode
->hdisplay
== high_w
&& mode
->vdisplay
== high_h
&&
520 mode
->vrefresh
< high_v
)
523 high_w
= mode
->hdisplay
;
524 high_h
= mode
->vdisplay
;
525 high_v
= mode
->vrefresh
;
529 NV_DEBUG_KMS(dev
, "native mode from largest: %dx%d@%d\n",
530 high_w
, high_h
, high_v
);
531 return largest
? drm_mode_duplicate(dev
, largest
) : NULL
;
539 static struct moderec scaler_modes
[] = {
558 nouveau_connector_scaler_modes_add(struct drm_connector
*connector
)
560 struct nouveau_connector
*nv_connector
= nouveau_connector(connector
);
561 struct drm_display_mode
*native
= nv_connector
->native_mode
, *m
;
562 struct drm_device
*dev
= connector
->dev
;
563 struct moderec
*mode
= &scaler_modes
[0];
569 while (mode
->hdisplay
) {
570 if (mode
->hdisplay
<= native
->hdisplay
&&
571 mode
->vdisplay
<= native
->vdisplay
) {
572 m
= drm_cvt_mode(dev
, mode
->hdisplay
, mode
->vdisplay
,
573 drm_mode_vrefresh(native
), false,
578 m
->type
|= DRM_MODE_TYPE_DRIVER
;
580 drm_mode_probed_add(connector
, m
);
591 nouveau_connector_get_modes(struct drm_connector
*connector
)
593 struct drm_device
*dev
= connector
->dev
;
594 struct drm_nouveau_private
*dev_priv
= dev
->dev_private
;
595 struct nouveau_connector
*nv_connector
= nouveau_connector(connector
);
596 struct nouveau_encoder
*nv_encoder
= nv_connector
->detected_encoder
;
597 struct drm_encoder
*encoder
= to_drm_encoder(nv_encoder
);
600 /* destroy the native mode, the attached monitor could have changed.
602 if (nv_connector
->native_mode
) {
603 drm_mode_destroy(dev
, nv_connector
->native_mode
);
604 nv_connector
->native_mode
= NULL
;
607 if (nv_connector
->edid
)
608 ret
= drm_add_edid_modes(connector
, nv_connector
->edid
);
610 if (nv_encoder
->dcb
->type
== OUTPUT_LVDS
&&
611 (nv_encoder
->dcb
->lvdsconf
.use_straps_for_mode
||
612 dev_priv
->vbios
.fp_no_ddc
) && nouveau_bios_fp_mode(dev
, NULL
)) {
613 struct drm_display_mode mode
;
615 nouveau_bios_fp_mode(dev
, &mode
);
616 nv_connector
->native_mode
= drm_mode_duplicate(dev
, &mode
);
619 /* Find the native mode if this is a digital panel, if we didn't
620 * find any modes through DDC previously add the native mode to
623 if (!nv_connector
->native_mode
)
624 nv_connector
->native_mode
=
625 nouveau_connector_native_mode(connector
);
626 if (ret
== 0 && nv_connector
->native_mode
) {
627 struct drm_display_mode
*mode
;
629 mode
= drm_mode_duplicate(dev
, nv_connector
->native_mode
);
630 drm_mode_probed_add(connector
, mode
);
634 if (nv_encoder
->dcb
->type
== OUTPUT_TV
)
635 ret
= get_slave_funcs(encoder
)->get_modes(encoder
, connector
);
637 if (nv_connector
->dcb
->type
== DCB_CONNECTOR_LVDS
||
638 nv_connector
->dcb
->type
== DCB_CONNECTOR_eDP
)
639 ret
+= nouveau_connector_scaler_modes_add(connector
);
645 nouveau_connector_mode_valid(struct drm_connector
*connector
,
646 struct drm_display_mode
*mode
)
648 struct drm_nouveau_private
*dev_priv
= connector
->dev
->dev_private
;
649 struct nouveau_connector
*nv_connector
= nouveau_connector(connector
);
650 struct nouveau_encoder
*nv_encoder
= nv_connector
->detected_encoder
;
651 struct drm_encoder
*encoder
= to_drm_encoder(nv_encoder
);
652 unsigned min_clock
= 25000, max_clock
= min_clock
;
653 unsigned clock
= mode
->clock
;
655 switch (nv_encoder
->dcb
->type
) {
657 if (nv_connector
->native_mode
&&
658 (mode
->hdisplay
> nv_connector
->native_mode
->hdisplay
||
659 mode
->vdisplay
> nv_connector
->native_mode
->vdisplay
))
666 if ((dev_priv
->card_type
>= NV_50
&& !nouveau_duallink
) ||
667 !nv_encoder
->dcb
->duallink_possible
)
673 max_clock
= nv_encoder
->dcb
->crtconf
.maxfreq
;
678 return get_slave_funcs(encoder
)->mode_valid(encoder
, mode
);
680 if (nv_encoder
->dp
.link_bw
== DP_LINK_BW_2_7
)
681 max_clock
= nv_encoder
->dp
.link_nr
* 270000;
683 max_clock
= nv_encoder
->dp
.link_nr
* 162000;
685 clock
= clock
* nouveau_connector_bpp(connector
) / 8;
692 if (clock
< min_clock
)
693 return MODE_CLOCK_LOW
;
695 if (clock
> max_clock
)
696 return MODE_CLOCK_HIGH
;
701 static struct drm_encoder
*
702 nouveau_connector_best_encoder(struct drm_connector
*connector
)
704 struct nouveau_connector
*nv_connector
= nouveau_connector(connector
);
706 if (nv_connector
->detected_encoder
)
707 return to_drm_encoder(nv_connector
->detected_encoder
);
713 nouveau_connector_set_polling(struct drm_connector
*connector
)
715 struct drm_device
*dev
= connector
->dev
;
716 struct drm_nouveau_private
*dev_priv
= dev
->dev_private
;
717 struct drm_crtc
*crtc
;
718 bool spare_crtc
= false;
720 list_for_each_entry(crtc
, &dev
->mode_config
.crtc_list
, head
)
721 spare_crtc
|= !crtc
->enabled
;
723 connector
->polled
= 0;
725 switch (connector
->connector_type
) {
726 case DRM_MODE_CONNECTOR_VGA
:
727 case DRM_MODE_CONNECTOR_TV
:
728 if (dev_priv
->card_type
>= NV_50
||
729 (nv_gf4_disp_arch(dev
) && spare_crtc
))
730 connector
->polled
= DRM_CONNECTOR_POLL_CONNECT
;
733 case DRM_MODE_CONNECTOR_DVII
:
734 case DRM_MODE_CONNECTOR_DVID
:
735 case DRM_MODE_CONNECTOR_HDMIA
:
736 case DRM_MODE_CONNECTOR_DisplayPort
:
737 case DRM_MODE_CONNECTOR_eDP
:
738 if (dev_priv
->card_type
>= NV_50
)
739 connector
->polled
= DRM_CONNECTOR_POLL_HPD
;
740 else if (connector
->connector_type
== DRM_MODE_CONNECTOR_DVID
||
742 connector
->polled
= DRM_CONNECTOR_POLL_CONNECT
;
750 static const struct drm_connector_helper_funcs
751 nouveau_connector_helper_funcs
= {
752 .get_modes
= nouveau_connector_get_modes
,
753 .mode_valid
= nouveau_connector_mode_valid
,
754 .best_encoder
= nouveau_connector_best_encoder
,
757 static const struct drm_connector_funcs
758 nouveau_connector_funcs
= {
759 .dpms
= drm_helper_connector_dpms
,
762 .detect
= nouveau_connector_detect
,
763 .destroy
= nouveau_connector_destroy
,
764 .fill_modes
= drm_helper_probe_single_connector_modes
,
765 .set_property
= nouveau_connector_set_property
,
766 .force
= nouveau_connector_force
769 static const struct drm_connector_funcs
770 nouveau_connector_funcs_lvds
= {
771 .dpms
= drm_helper_connector_dpms
,
774 .detect
= nouveau_connector_detect_lvds
,
775 .destroy
= nouveau_connector_destroy
,
776 .fill_modes
= drm_helper_probe_single_connector_modes
,
777 .set_property
= nouveau_connector_set_property
,
778 .force
= nouveau_connector_force
781 struct drm_connector
*
782 nouveau_connector_create(struct drm_device
*dev
, int index
)
784 const struct drm_connector_funcs
*funcs
= &nouveau_connector_funcs
;
785 struct drm_nouveau_private
*dev_priv
= dev
->dev_private
;
786 struct nouveau_connector
*nv_connector
= NULL
;
787 struct dcb_connector_table_entry
*dcb
= NULL
;
788 struct drm_connector
*connector
;
791 NV_DEBUG_KMS(dev
, "\n");
793 if (index
>= dev_priv
->vbios
.dcb
.connector
.entries
)
794 return ERR_PTR(-EINVAL
);
796 dcb
= &dev_priv
->vbios
.dcb
.connector
.entry
[index
];
801 case DCB_CONNECTOR_VGA
:
802 type
= DRM_MODE_CONNECTOR_VGA
;
804 case DCB_CONNECTOR_TV_0
:
805 case DCB_CONNECTOR_TV_1
:
806 case DCB_CONNECTOR_TV_3
:
807 type
= DRM_MODE_CONNECTOR_TV
;
809 case DCB_CONNECTOR_DVI_I
:
810 type
= DRM_MODE_CONNECTOR_DVII
;
812 case DCB_CONNECTOR_DVI_D
:
813 type
= DRM_MODE_CONNECTOR_DVID
;
815 case DCB_CONNECTOR_HDMI_0
:
816 case DCB_CONNECTOR_HDMI_1
:
817 type
= DRM_MODE_CONNECTOR_HDMIA
;
819 case DCB_CONNECTOR_LVDS
:
820 type
= DRM_MODE_CONNECTOR_LVDS
;
821 funcs
= &nouveau_connector_funcs_lvds
;
823 case DCB_CONNECTOR_DP
:
824 type
= DRM_MODE_CONNECTOR_DisplayPort
;
826 case DCB_CONNECTOR_eDP
:
827 type
= DRM_MODE_CONNECTOR_eDP
;
830 NV_ERROR(dev
, "unknown connector type: 0x%02x!!\n", dcb
->type
);
831 return ERR_PTR(-EINVAL
);
834 nv_connector
= kzalloc(sizeof(*nv_connector
), GFP_KERNEL
);
836 return ERR_PTR(-ENOMEM
);
837 nv_connector
->dcb
= dcb
;
838 connector
= &nv_connector
->base
;
840 /* defaults, will get overridden in detect() */
841 connector
->interlace_allowed
= false;
842 connector
->doublescan_allowed
= false;
844 drm_connector_init(dev
, connector
, funcs
, type
);
845 drm_connector_helper_add(connector
, &nouveau_connector_helper_funcs
);
847 /* Check if we need dithering enabled */
848 if (dcb
->type
== DCB_CONNECTOR_LVDS
) {
849 bool dummy
, is_24bit
= false;
851 ret
= nouveau_bios_parse_lvds_table(dev
, 0, &dummy
, &is_24bit
);
853 NV_ERROR(dev
, "Error parsing LVDS table, disabling "
858 nv_connector
->use_dithering
= !is_24bit
;
861 /* Init DVI-I specific properties */
862 if (dcb
->type
== DCB_CONNECTOR_DVI_I
) {
863 drm_mode_create_dvi_i_properties(dev
);
864 drm_connector_attach_property(connector
, dev
->mode_config
.dvi_i_subconnector_property
, 0);
865 drm_connector_attach_property(connector
, dev
->mode_config
.dvi_i_select_subconnector_property
, 0);
869 case DCB_CONNECTOR_VGA
:
870 if (dev_priv
->card_type
>= NV_50
) {
871 drm_connector_attach_property(connector
,
872 dev
->mode_config
.scaling_mode_property
,
873 nv_connector
->scaling_mode
);
876 case DCB_CONNECTOR_TV_0
:
877 case DCB_CONNECTOR_TV_1
:
878 case DCB_CONNECTOR_TV_3
:
879 nv_connector
->scaling_mode
= DRM_MODE_SCALE_NONE
;
882 nv_connector
->scaling_mode
= DRM_MODE_SCALE_FULLSCREEN
;
884 drm_connector_attach_property(connector
,
885 dev
->mode_config
.scaling_mode_property
,
886 nv_connector
->scaling_mode
);
887 drm_connector_attach_property(connector
,
888 dev
->mode_config
.dithering_mode_property
,
889 nv_connector
->use_dithering
?
890 DRM_MODE_DITHERING_ON
: DRM_MODE_DITHERING_OFF
);
894 nouveau_connector_set_polling(connector
);
896 drm_sysfs_connector_add(connector
);
897 dcb
->drm
= connector
;
901 drm_connector_cleanup(connector
);