projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
drm/nouveau: place notifiers in system memory by default
[linux-2.6-block.git] / drivers / gpu / drm / nouveau / nouveau_connector.c
CommitLineData
6ee73861
BS		 1/*
2 * Copyright (C) 2008 Maarten Maathuis.
3 * All Rights Reserved.
4 *
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:
12 *
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.
16 *
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.
24 *
25 */
26
a1470890
BS		 27#include <acpi/button.h>
28
6ee73861
BS		 29#include "drmP.h"
30#include "drm_edid.h"
31#include "drm_crtc_helper.h"
a1470890 32
6ee73861
BS		 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"
39
40static inline struct drm_encoder_slave_funcs *
41get_slave_funcs(struct nouveau_encoder *enc)
42{
43 return to_encoder_slave(to_drm_encoder(enc))->slave_funcs;
44}
45
46static struct nouveau_encoder *
47find_encoder_by_type(struct drm_connector *connector, int type)
48{
49 struct drm_device *dev = connector->dev;
50 struct nouveau_encoder *nv_encoder;
51 struct drm_mode_object *obj;
52 int i, id;
53
54 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
55 id = connector->encoder_ids[i];
56 if (!id)
57 break;
58
59 obj = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_ENCODER);
60 if (!obj)
61 continue;
62 nv_encoder = nouveau_encoder(obj_to_encoder(obj));
63
64 if (type == OUTPUT_ANY || nv_encoder->dcb->type == type)
65 return nv_encoder;
66 }
67
68 return NULL;
69}
70
71struct nouveau_connector *
72nouveau_encoder_connector_get(struct nouveau_encoder *encoder)
73{
74 struct drm_device *dev = to_drm_encoder(encoder)->dev;
75 struct drm_connector *drm_connector;
76
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);
80 }
81
82 return NULL;
83}
84
85
86static void
87nouveau_connector_destroy(struct drm_connector *drm_connector)
88{
c8ebe275
XC		 89 struct nouveau_connector *nv_connector =
90 nouveau_connector(drm_connector);
dd19e44b 91 struct drm_device *dev;
6ee73861 92
c8ebe275 93 if (!nv_connector)
6ee73861
BS		 94 return;
95
dd19e44b
MS		 96 dev = nv_connector->base.dev;
97 NV_DEBUG_KMS(dev, "\n");
98
c8ebe275 99 kfree(nv_connector->edid);
6ee73861
BS		 100 drm_sysfs_connector_remove(drm_connector);
101 drm_connector_cleanup(drm_connector);
102 kfree(drm_connector);
103}
104
105static void
106nouveau_connector_ddc_prepare(struct drm_connector *connector, int *flags)
107{
108 struct drm_nouveau_private *dev_priv = connector->dev->dev_private;
109
110 if (dev_priv->card_type >= NV_50)
111 return;
112
113 *flags = 0;
114 if (NVLockVgaCrtcs(dev_priv->dev, false))
115 *flags |= 1;
116 if (nv_heads_tied(dev_priv->dev))
117 *flags |= 2;
118
119 if (*flags & 2)
120 NVSetOwner(dev_priv->dev, 0); /* necessary? */
121}
122
123static void
124nouveau_connector_ddc_finish(struct drm_connector *connector, int flags)
125{
126 struct drm_nouveau_private *dev_priv = connector->dev->dev_private;
127
128 if (dev_priv->card_type >= NV_50)
129 return;
130
131 if (flags & 2)
132 NVSetOwner(dev_priv->dev, 4);
133 if (flags & 1)
134 NVLockVgaCrtcs(dev_priv->dev, true);
135}
136
137static struct nouveau_i2c_chan *
138nouveau_connector_ddc_detect(struct drm_connector *connector,
139 struct nouveau_encoder **pnv_encoder)
140{
141 struct drm_device *dev = connector->dev;
142 uint8_t out_buf[] = { 0x0, 0x0}, buf[2];
143 int ret, flags, i;
144
145 struct i2c_msg msgs[] = {
146 {
147 .addr = 0x50,
148 .flags = 0,
149 .len = 1,
150 .buf = out_buf,
151 },
152 {
153 .addr = 0x50,
154 .flags = I2C_M_RD,
155 .len = 1,
156 .buf = buf,
157 }
158 };
159
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;
164 int id;
165
166 id = connector->encoder_ids[i];
167 if (!id)
168 break;
169
170 obj = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_ENCODER);
171 if (!obj)
172 continue;
173 nv_encoder = nouveau_encoder(obj_to_encoder(obj));
174
175 if (nv_encoder->dcb->i2c_index < 0xf)
176 i2c = nouveau_i2c_find(dev, nv_encoder->dcb->i2c_index);
177 if (!i2c)
178 continue;
179
180 nouveau_connector_ddc_prepare(connector, &flags);
181 ret = i2c_transfer(&i2c->adapter, msgs, 2);
182 nouveau_connector_ddc_finish(connector, flags);
183
184 if (ret == 2) {
185 *pnv_encoder = nv_encoder;
186 return i2c;
187 }
188 }
189
190 return NULL;
191}
192
193static void
194nouveau_connector_set_encoder(struct drm_connector *connector,
195 struct nouveau_encoder *nv_encoder)
196{
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;
200
201 if (nv_connector->detected_encoder == nv_encoder)
202 return;
203 nv_connector->detected_encoder = nv_encoder;
204
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;
209 } else {
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))
215 /* HW is broken */
216 connector->interlace_allowed = false;
217 else
218 connector->interlace_allowed = true;
219 }
220
be079e97 221 if (nv_connector->dcb->type == DCB_CONNECTOR_DVI_I) {
6ee73861
BS		 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);
227 }
228}
229
230static enum drm_connector_status
231nouveau_connector_detect(struct drm_connector *connector)
232{
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;
237 int type, flags;
238
be079e97 239 if (nv_connector->dcb->type == DCB_CONNECTOR_LVDS)
6ee73861
BS		 240 nv_encoder = find_encoder_by_type(connector, OUTPUT_LVDS);
241 if (nv_encoder && nv_connector->native_mode) {
b30083bd
BS		 242 unsigned status = connector_status_connected;
243
57976602
RD		 244#if defined(CONFIG_ACPI_BUTTON) || \
245 (defined(CONFIG_ACPI_BUTTON_MODULE) && defined(MODULE))
a1470890 246 if (!nouveau_ignorelid && !acpi_lid_open())
b30083bd 247 status = connector_status_unknown;
a1470890 248#endif
6ee73861 249 nouveau_connector_set_encoder(connector, nv_encoder);
b30083bd 250 return status;
6ee73861
BS		 251 }
252
b8780e2a
FJ		 253 /* Cleanup the previous EDID block. */
254 if (nv_connector->edid) {
255 drm_mode_connector_update_edid_property(connector, NULL);
256 kfree(nv_connector->edid);
257 nv_connector->edid = NULL;
258 }
c8ebe275 259
6ee73861
BS		 260 i2c = nouveau_connector_ddc_detect(connector, &nv_encoder);
261 if (i2c) {
262 nouveau_connector_ddc_prepare(connector, &flags);
263 nv_connector->edid = drm_get_edid(connector, &i2c->adapter);
264 nouveau_connector_ddc_finish(connector, flags);
265 drm_mode_connector_update_edid_property(connector,
266 nv_connector->edid);
267 if (!nv_connector->edid) {
268 NV_ERROR(dev, "DDC responded, but no EDID for %s\n",
269 drm_get_connector_name(connector));
0ed3165e 270 goto detect_analog;
6ee73861
BS		 271 }
272
273 if (nv_encoder->dcb->type == OUTPUT_DP &&
274 !nouveau_dp_detect(to_drm_encoder(nv_encoder))) {
275 NV_ERROR(dev, "Detected %s, but failed init\n",
276 drm_get_connector_name(connector));
277 return connector_status_disconnected;
278 }
279
280 /* Override encoder type for DVI-I based on whether EDID
281 * says the display is digital or analog, both use the
282 * same i2c channel so the value returned from ddc_detect
283 * isn't necessarily correct.
284 */
be079e97 285 if (nv_connector->dcb->type == DCB_CONNECTOR_DVI_I) {
6ee73861
BS		 286 if (nv_connector->edid->input & DRM_EDID_INPUT_DIGITAL)
287 type = OUTPUT_TMDS;
288 else
289 type = OUTPUT_ANALOG;
290
291 nv_encoder = find_encoder_by_type(connector, type);
292 if (!nv_encoder) {
293 NV_ERROR(dev, "Detected %d encoder on %s, "
294 "but no object!\n", type,
295 drm_get_connector_name(connector));
296 return connector_status_disconnected;
297 }
298 }
299
300 nouveau_connector_set_encoder(connector, nv_encoder);
301 return connector_status_connected;
302 }
303
0ed3165e 304detect_analog:
6ee73861 305 nv_encoder = find_encoder_by_type(connector, OUTPUT_ANALOG);
f4053509 306 if (!nv_encoder && !nouveau_tv_disable)
6ee73861
BS		 307 nv_encoder = find_encoder_by_type(connector, OUTPUT_TV);
308 if (nv_encoder) {
309 struct drm_encoder *encoder = to_drm_encoder(nv_encoder);
310 struct drm_encoder_helper_funcs *helper =
311 encoder->helper_private;
312
313 if (helper->detect(encoder, connector) ==
314 connector_status_connected) {
315 nouveau_connector_set_encoder(connector, nv_encoder);
316 return connector_status_connected;
317 }
318
319 }
320
321 return connector_status_disconnected;
322}
323
324static void
325nouveau_connector_force(struct drm_connector *connector)
326{
be079e97 327 struct nouveau_connector *nv_connector = nouveau_connector(connector);
6ee73861
BS		 328 struct nouveau_encoder *nv_encoder;
329 int type;
330
be079e97 331 if (nv_connector->dcb->type == DCB_CONNECTOR_DVI_I) {
6ee73861
BS		 332 if (connector->force == DRM_FORCE_ON_DIGITAL)
333 type = OUTPUT_TMDS;
334 else
335 type = OUTPUT_ANALOG;
336 } else
337 type = OUTPUT_ANY;
338
339 nv_encoder = find_encoder_by_type(connector, type);
340 if (!nv_encoder) {
be079e97 341 NV_ERROR(connector->dev, "can't find encoder to force %s on!\n",
6ee73861
BS		 342 drm_get_connector_name(connector));
343 connector->status = connector_status_disconnected;
344 return;
345 }
346
347 nouveau_connector_set_encoder(connector, nv_encoder);
348}
349
350static int
351nouveau_connector_set_property(struct drm_connector *connector,
352 struct drm_property *property, uint64_t value)
353{
354 struct nouveau_connector *nv_connector = nouveau_connector(connector);
355 struct nouveau_encoder *nv_encoder = nv_connector->detected_encoder;
356 struct drm_device *dev = connector->dev;
357 int ret;
358
359 /* Scaling mode */
360 if (property == dev->mode_config.scaling_mode_property) {
361 struct nouveau_crtc *nv_crtc = NULL;
362 bool modeset = false;
363
364 switch (value) {
365 case DRM_MODE_SCALE_NONE:
366 case DRM_MODE_SCALE_FULLSCREEN:
367 case DRM_MODE_SCALE_CENTER:
368 case DRM_MODE_SCALE_ASPECT:
369 break;
370 default:
371 return -EINVAL;
372 }
373
374 /* LVDS always needs gpu scaling */
be079e97 375 if (nv_connector->dcb->type == DCB_CONNECTOR_LVDS &&
6ee73861
BS		 376 value == DRM_MODE_SCALE_NONE)
377 return -EINVAL;
378
379 /* Changing between GPU and panel scaling requires a full
380 * modeset
381 */
382 if ((nv_connector->scaling_mode == DRM_MODE_SCALE_NONE) ||
383 (value == DRM_MODE_SCALE_NONE))
384 modeset = true;
385 nv_connector->scaling_mode = value;
386
387 if (connector->encoder && connector->encoder->crtc)
388 nv_crtc = nouveau_crtc(connector->encoder->crtc);
389 if (!nv_crtc)
390 return 0;
391
392 if (modeset || !nv_crtc->set_scale) {
393 ret = drm_crtc_helper_set_mode(&nv_crtc->base,
394 &nv_crtc->base.mode,
395 nv_crtc->base.x,
396 nv_crtc->base.y, NULL);
397 if (!ret)
398 return -EINVAL;
399 } else {
400 ret = nv_crtc->set_scale(nv_crtc, value, true);
401 if (ret)
402 return ret;
403 }
404
405 return 0;
406 }
407
408 /* Dithering */
409 if (property == dev->mode_config.dithering_mode_property) {
410 struct nouveau_crtc *nv_crtc = NULL;
411
412 if (value == DRM_MODE_DITHERING_ON)
413 nv_connector->use_dithering = true;
414 else
415 nv_connector->use_dithering = false;
416
417 if (connector->encoder && connector->encoder->crtc)
418 nv_crtc = nouveau_crtc(connector->encoder->crtc);
419
420 if (!nv_crtc || !nv_crtc->set_dither)
421 return 0;
422
423 return nv_crtc->set_dither(nv_crtc, nv_connector->use_dithering,
424 true);
425 }
426
427 if (nv_encoder && nv_encoder->dcb->type == OUTPUT_TV)
428 return get_slave_funcs(nv_encoder)->
429 set_property(to_drm_encoder(nv_encoder), connector, property, value);
430
431 return -EINVAL;
432}
433
434static struct drm_display_mode *
26099a74 435nouveau_connector_native_mode(struct drm_connector *connector)
6ee73861 436{
26099a74
BS		 437 struct drm_connector_helper_funcs *helper = connector->helper_private;
438 struct nouveau_connector *nv_connector = nouveau_connector(connector);
439 struct drm_device *dev = connector->dev;
6ee73861
BS		 440 struct drm_display_mode *mode, *largest = NULL;
441 int high_w = 0, high_h = 0, high_v = 0;
442
26099a74
BS		 443 list_for_each_entry(mode, &nv_connector->base.probed_modes, head) {
444 if (helper->mode_valid(connector, mode) != MODE_OK)
445 continue;
446
447 /* Use preferred mode if there is one.. */
6ee73861 448 if (mode->type & DRM_MODE_TYPE_PREFERRED) {
ef2bb506 449 NV_DEBUG_KMS(dev, "native mode from preferred\n");
6ee73861
BS		 450 return drm_mode_duplicate(dev, mode);
451 }
6ee73861 452
26099a74
BS		 453 /* Otherwise, take the resolution with the largest width, then
454 * height, then vertical refresh
455 */
6ee73861
BS		 456 if (mode->hdisplay < high_w)
457 continue;
458
459 if (mode->hdisplay == high_w && mode->vdisplay < high_h)
460 continue;
461
462 if (mode->hdisplay == high_w && mode->vdisplay == high_h &&
463 mode->vrefresh < high_v)
464 continue;
465
466 high_w = mode->hdisplay;
467 high_h = mode->vdisplay;
468 high_v = mode->vrefresh;
469 largest = mode;
470 }
471
ef2bb506 472 NV_DEBUG_KMS(dev, "native mode from largest: %dx%d@%d\n",
6ee73861
BS		 473 high_w, high_h, high_v);
474 return largest ? drm_mode_duplicate(dev, largest) : NULL;
475}
476
477struct moderec {
478 int hdisplay;
479 int vdisplay;
480};
481
482static struct moderec scaler_modes[] = {
483 { 1920, 1200 },
484 { 1920, 1080 },
485 { 1680, 1050 },
486 { 1600, 1200 },
487 { 1400, 1050 },
488 { 1280, 1024 },
489 { 1280, 960 },
490 { 1152, 864 },
491 { 1024, 768 },
492 { 800, 600 },
493 { 720, 400 },
494 { 640, 480 },
495 { 640, 400 },
496 { 640, 350 },
497 {}
498};
499
500static int
501nouveau_connector_scaler_modes_add(struct drm_connector *connector)
502{
503 struct nouveau_connector *nv_connector = nouveau_connector(connector);
504 struct drm_display_mode *native = nv_connector->native_mode, *m;
505 struct drm_device *dev = connector->dev;
506 struct moderec *mode = &scaler_modes[0];
507 int modes = 0;
508
509 if (!native)
510 return 0;
511
512 while (mode->hdisplay) {
513 if (mode->hdisplay <= native->hdisplay &&
514 mode->vdisplay <= native->vdisplay) {
515 m = drm_cvt_mode(dev, mode->hdisplay, mode->vdisplay,
516 drm_mode_vrefresh(native), false,
517 false, false);
518 if (!m)
519 continue;
520
521 m->type |= DRM_MODE_TYPE_DRIVER;
522
523 drm_mode_probed_add(connector, m);
524 modes++;
525 }
526
527 mode++;
528 }
529
530 return modes;
531}
532
533static int
534nouveau_connector_get_modes(struct drm_connector *connector)
535{
536 struct drm_device *dev = connector->dev;
537 struct nouveau_connector *nv_connector = nouveau_connector(connector);
538 struct nouveau_encoder *nv_encoder = nv_connector->detected_encoder;
539 int ret = 0;
540
541 /* If we're not LVDS, destroy the previous native mode, the attached
542 * monitor could have changed.
543 */
be079e97 544 if (nv_connector->dcb->type != DCB_CONNECTOR_LVDS &&
6ee73861
BS		 545 nv_connector->native_mode) {
546 drm_mode_destroy(dev, nv_connector->native_mode);
547 nv_connector->native_mode = NULL;
548 }
549
550 if (nv_connector->edid)
551 ret = drm_add_edid_modes(connector, nv_connector->edid);
552
553 /* Find the native mode if this is a digital panel, if we didn't
554 * find any modes through DDC previously add the native mode to
555 * the list of modes.
556 */
557 if (!nv_connector->native_mode)
558 nv_connector->native_mode =
26099a74 559 nouveau_connector_native_mode(connector);
6ee73861
BS		 560 if (ret == 0 && nv_connector->native_mode) {
561 struct drm_display_mode *mode;
562
563 mode = drm_mode_duplicate(dev, nv_connector->native_mode);
564 drm_mode_probed_add(connector, mode);
565 ret = 1;
566 }
567
568 if (nv_encoder->dcb->type == OUTPUT_TV)
569 ret = get_slave_funcs(nv_encoder)->
570 get_modes(to_drm_encoder(nv_encoder), connector);
571
be079e97 572 if (nv_encoder->dcb->type == OUTPUT_LVDS)
6ee73861
BS		 573 ret += nouveau_connector_scaler_modes_add(connector);
574
575 return ret;
576}
577
578static int
579nouveau_connector_mode_valid(struct drm_connector *connector,
580 struct drm_display_mode *mode)
581{
582 struct drm_nouveau_private *dev_priv = connector->dev->dev_private;
583 struct nouveau_connector *nv_connector = nouveau_connector(connector);
584 struct nouveau_encoder *nv_encoder = nv_connector->detected_encoder;
585 unsigned min_clock = 25000, max_clock = min_clock;
586 unsigned clock = mode->clock;
587
588 switch (nv_encoder->dcb->type) {
589 case OUTPUT_LVDS:
26099a74
BS		 590 if (nv_connector->native_mode &&
591 (mode->hdisplay > nv_connector->native_mode->hdisplay ||
592 mode->vdisplay > nv_connector->native_mode->vdisplay))
6ee73861
BS		 593 return MODE_PANEL;
594
595 min_clock = 0;
596 max_clock = 400000;
597 break;
598 case OUTPUT_TMDS:
599 if ((dev_priv->card_type >= NV_50 && !nouveau_duallink) ||
2c580775 600 !nv_encoder->dcb->duallink_possible)
6ee73861
BS		 601 max_clock = 165000;
602 else
603 max_clock = 330000;
604 break;
605 case OUTPUT_ANALOG:
606 max_clock = nv_encoder->dcb->crtconf.maxfreq;
607 if (!max_clock)
608 max_clock = 350000;
609 break;
610 case OUTPUT_TV:
611 return get_slave_funcs(nv_encoder)->
612 mode_valid(to_drm_encoder(nv_encoder), mode);
613 case OUTPUT_DP:
614 if (nv_encoder->dp.link_bw == DP_LINK_BW_2_7)
615 max_clock = nv_encoder->dp.link_nr * 270000;
616 else
617 max_clock = nv_encoder->dp.link_nr * 162000;
618
619 clock *= 3;
620 break;
e7cc51c5
BS		 621 default:
622 BUG_ON(1);
623 return MODE_BAD;
6ee73861
BS		 624 }
625
626 if (clock < min_clock)
627 return MODE_CLOCK_LOW;
628
629 if (clock > max_clock)
630 return MODE_CLOCK_HIGH;
631
632 return MODE_OK;
633}
634
635static struct drm_encoder *
636nouveau_connector_best_encoder(struct drm_connector *connector)
637{
638 struct nouveau_connector *nv_connector = nouveau_connector(connector);
639
640 if (nv_connector->detected_encoder)
641 return to_drm_encoder(nv_connector->detected_encoder);
642
643 return NULL;
644}
645
646static const struct drm_connector_helper_funcs
647nouveau_connector_helper_funcs = {
648 .get_modes = nouveau_connector_get_modes,
649 .mode_valid = nouveau_connector_mode_valid,
650 .best_encoder = nouveau_connector_best_encoder,
651};
652
653static const struct drm_connector_funcs
654nouveau_connector_funcs = {
655 .dpms = drm_helper_connector_dpms,
656 .save = NULL,
657 .restore = NULL,
658 .detect = nouveau_connector_detect,
659 .destroy = nouveau_connector_destroy,
660 .fill_modes = drm_helper_probe_single_connector_modes,
661 .set_property = nouveau_connector_set_property,
662 .force = nouveau_connector_force
663};
664
665static int
666nouveau_connector_create_lvds(struct drm_device *dev,
667 struct drm_connector *connector)
668{
669 struct nouveau_connector *nv_connector = nouveau_connector(connector);
670 struct drm_nouveau_private *dev_priv = dev->dev_private;
671 struct nouveau_i2c_chan *i2c = NULL;
672 struct nouveau_encoder *nv_encoder;
673 struct drm_display_mode native, *mode, *temp;
674 bool dummy, if_is_24bit = false;
675 int ret, flags;
676
677 nv_encoder = find_encoder_by_type(connector, OUTPUT_LVDS);
678 if (!nv_encoder)
679 return -ENODEV;
680
681 ret = nouveau_bios_parse_lvds_table(dev, 0, &dummy, &if_is_24bit);
682 if (ret) {
683 NV_ERROR(dev, "Error parsing LVDS table, disabling LVDS\n");
684 return ret;
685 }
686 nv_connector->use_dithering = !if_is_24bit;
687
688 /* Firstly try getting EDID over DDC, if allowed and I2C channel
689 * is available.
690 */
04a39c57 691 if (!dev_priv->vbios.fp_no_ddc && nv_encoder->dcb->i2c_index < 0xf)
6ee73861
BS		 692 i2c = nouveau_i2c_find(dev, nv_encoder->dcb->i2c_index);
693
694 if (i2c) {
695 nouveau_connector_ddc_prepare(connector, &flags);
696 nv_connector->edid = drm_get_edid(connector, &i2c->adapter);
697 nouveau_connector_ddc_finish(connector, flags);
698 }
699
700 /* If no EDID found above, and the VBIOS indicates a hardcoded
701 * modeline is avalilable for the panel, set it as the panel's
702 * native mode and exit.
703 */
704 if (!nv_connector->edid && nouveau_bios_fp_mode(dev, &native) &&
705 (nv_encoder->dcb->lvdsconf.use_straps_for_mode ||
04a39c57 706 dev_priv->vbios.fp_no_ddc)) {
6ee73861
BS		 707 nv_connector->native_mode = drm_mode_duplicate(dev, &native);
708 goto out;
709 }
710
711 /* Still nothing, some VBIOS images have a hardcoded EDID block
712 * stored for the panel stored in them.
713 */
714 if (!nv_connector->edid && !nv_connector->native_mode &&
04a39c57 715 !dev_priv->vbios.fp_no_ddc) {
c8ebe275 716 struct edid *edid =
6ee73861 717 (struct edid *)nouveau_bios_embedded_edid(dev);
c8ebe275
XC		 718 if (edid) {
719 nv_connector->edid = kmalloc(EDID_LENGTH, GFP_KERNEL);
720 *(nv_connector->edid) = *edid;
721 }
6ee73861
BS		 722 }
723
724 if (!nv_connector->edid)
725 goto out;
726
727 /* We didn't find/use a panel mode from the VBIOS, so parse the EDID
728 * block and look for the preferred mode there.
729 */
730 ret = drm_add_edid_modes(connector, nv_connector->edid);
731 if (ret == 0)
732 goto out;
733 nv_connector->detected_encoder = nv_encoder;
26099a74 734 nv_connector->native_mode = nouveau_connector_native_mode(connector);
6ee73861
BS		 735 list_for_each_entry_safe(mode, temp, &connector->probed_modes, head)
736 drm_mode_remove(connector, mode);
737
738out:
739 if (!nv_connector->native_mode) {
740 NV_ERROR(dev, "LVDS present in DCB table, but couldn't "
741 "determine its native mode. Disabling.\n");
742 return -ENODEV;
743 }
744
745 drm_mode_connector_update_edid_property(connector, nv_connector->edid);
746 return 0;
747}
748
749int
7f612d87
BS		 750nouveau_connector_create(struct drm_device *dev,
751 struct dcb_connector_table_entry *dcb)
6ee73861
BS		 752{
753 struct drm_nouveau_private *dev_priv = dev->dev_private;
754 struct nouveau_connector *nv_connector = NULL;
755 struct drm_connector *connector;
756 struct drm_encoder *encoder;
7f612d87 757 int ret, type;
6ee73861 758
ef2bb506 759 NV_DEBUG_KMS(dev, "\n");
6ee73861 760
7f612d87
BS		 761 switch (dcb->type) {
762 case DCB_CONNECTOR_NONE:
763 return 0;
764 case DCB_CONNECTOR_VGA:
6ee73861 765 NV_INFO(dev, "Detected a VGA connector\n");
7f612d87 766 type = DRM_MODE_CONNECTOR_VGA;
6ee73861 767 break;
7f612d87
BS		 768 case DCB_CONNECTOR_TV_0:
769 case DCB_CONNECTOR_TV_1:
770 case DCB_CONNECTOR_TV_3:
771 NV_INFO(dev, "Detected a TV connector\n");
772 type = DRM_MODE_CONNECTOR_TV;
6ee73861 773 break;
7f612d87 774 case DCB_CONNECTOR_DVI_I:
6ee73861 775 NV_INFO(dev, "Detected a DVI-I connector\n");
7f612d87 776 type = DRM_MODE_CONNECTOR_DVII;
6ee73861 777 break;
7f612d87 778 case DCB_CONNECTOR_DVI_D:
7f612d87
BS		 779 NV_INFO(dev, "Detected a DVI-D connector\n");
780 type = DRM_MODE_CONNECTOR_DVID;
6ee73861 781 break;
be079e97
BS		 782 case DCB_CONNECTOR_HDMI_0:
783 case DCB_CONNECTOR_HDMI_1:
784 NV_INFO(dev, "Detected a HDMI connector\n");
785 type = DRM_MODE_CONNECTOR_HDMIA;
786 break;
7f612d87
BS		 787 case DCB_CONNECTOR_LVDS:
788 NV_INFO(dev, "Detected a LVDS connector\n");
789 type = DRM_MODE_CONNECTOR_LVDS;
6ee73861 790 break;
7f612d87 791 case DCB_CONNECTOR_DP:
6ee73861 792 NV_INFO(dev, "Detected a DisplayPort connector\n");
7f612d87 793 type = DRM_MODE_CONNECTOR_DisplayPort;
6ee73861 794 break;
be079e97
BS		 795 case DCB_CONNECTOR_eDP:
796 NV_INFO(dev, "Detected an eDP connector\n");
797 type = DRM_MODE_CONNECTOR_eDP;
798 break;
6ee73861 799 default:
7f612d87
BS		 800 NV_ERROR(dev, "unknown connector type: 0x%02x!!\n", dcb->type);
801 return -EINVAL;
6ee73861
BS		 802 }
803
7f612d87
BS		 804 nv_connector = kzalloc(sizeof(*nv_connector), GFP_KERNEL);
805 if (!nv_connector)
806 return -ENOMEM;
807 nv_connector->dcb = dcb;
808 connector = &nv_connector->base;
809
6ee73861
BS		 810 /* defaults, will get overridden in detect() */
811 connector->interlace_allowed = false;
812 connector->doublescan_allowed = false;
813
814 drm_connector_init(dev, connector, &nouveau_connector_funcs, type);
815 drm_connector_helper_add(connector, &nouveau_connector_helper_funcs);
816
7f612d87
BS		 817 /* attach encoders */
818 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
819 struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
820
821 if (nv_encoder->dcb->connector != dcb->index)
822 continue;
823
824 if (get_slave_funcs(nv_encoder))
825 get_slave_funcs(nv_encoder)->create_resources(encoder, connector);
826
827 drm_mode_connector_attach_encoder(connector, encoder);
828 }
829
830 if (!connector->encoder_ids[0]) {
831 NV_WARN(dev, " no encoders, ignoring\n");
832 drm_connector_cleanup(connector);
833 kfree(connector);
834 return 0;
835 }
836
6ee73861 837 /* Init DVI-I specific properties */
be079e97 838 if (dcb->type == DCB_CONNECTOR_DVI_I) {
6ee73861
BS		 839 drm_mode_create_dvi_i_properties(dev);
840 drm_connector_attach_property(connector, dev->mode_config.dvi_i_subconnector_property, 0);
841 drm_connector_attach_property(connector, dev->mode_config.dvi_i_select_subconnector_property, 0);
842 }
843
be079e97 844 if (dcb->type != DCB_CONNECTOR_LVDS)
6ee73861
BS		 845 nv_connector->use_dithering = false;
846
be079e97
BS		 847 switch (dcb->type) {
848 case DCB_CONNECTOR_VGA:
eb1f8e4f 849 connector->polled = DRM_CONNECTOR_POLL_CONNECT;
be079e97 850 if (dev_priv->card_type >= NV_50) {
6ee73861
BS		 851 drm_connector_attach_property(connector,
852 dev->mode_config.scaling_mode_property,
853 nv_connector->scaling_mode);
854 }
be079e97
BS		 855 /* fall-through */
856 case DCB_CONNECTOR_TV_0:
857 case DCB_CONNECTOR_TV_1:
858 case DCB_CONNECTOR_TV_3:
859 nv_connector->scaling_mode = DRM_MODE_SCALE_NONE;
860 break;
eb1f8e4f
DA		 861 case DCB_CONNECTOR_DP:
862 case DCB_CONNECTOR_eDP:
863 case DCB_CONNECTOR_HDMI_0:
864 case DCB_CONNECTOR_HDMI_1:
865 case DCB_CONNECTOR_DVI_I:
866 case DCB_CONNECTOR_DVI_D:
867 if (dev_priv->card_type >= NV_50)
868 connector->polled = DRM_CONNECTOR_POLL_HPD;
869 else
870 connector->polled = DRM_CONNECTOR_POLL_CONNECT;
871 /* fall-through */
be079e97
BS		 872 default:
873 nv_connector->scaling_mode = DRM_MODE_SCALE_FULLSCREEN;
874
875 drm_connector_attach_property(connector,
876 dev->mode_config.scaling_mode_property,
877 nv_connector->scaling_mode);
878 drm_connector_attach_property(connector,
879 dev->mode_config.dithering_mode_property,
880 nv_connector->use_dithering ?
881 DRM_MODE_DITHERING_ON : DRM_MODE_DITHERING_OFF);
882 break;
6ee73861
BS		 883 }
884
6ee73861
BS		 885 drm_sysfs_connector_add(connector);
886
be079e97 887 if (dcb->type == DCB_CONNECTOR_LVDS) {
6ee73861
BS		 888 ret = nouveau_connector_create_lvds(dev, connector);
889 if (ret) {
890 connector->funcs->destroy(connector);
891 return ret;
892 }
893 }
894
895 return 0;
896}
Linux 6.x block layer and io_uring tree(s)