projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
drm/nouveau: fix uninitialised variable warning
[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
fce2bad0
BS		 40static void nouveau_connector_hotplug(void *, int);
41
6ee73861
BS		 42static struct nouveau_encoder *
43find_encoder_by_type(struct drm_connector *connector, int type)
44{
45 struct drm_device *dev = connector->dev;
46 struct nouveau_encoder *nv_encoder;
47 struct drm_mode_object *obj;
48 int i, id;
49
50 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
51 id = connector->encoder_ids[i];
52 if (!id)
53 break;
54
55 obj = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_ENCODER);
56 if (!obj)
57 continue;
58 nv_encoder = nouveau_encoder(obj_to_encoder(obj));
59
60 if (type == OUTPUT_ANY || nv_encoder->dcb->type == type)
61 return nv_encoder;
62 }
63
64 return NULL;
65}
66
67struct nouveau_connector *
68nouveau_encoder_connector_get(struct nouveau_encoder *encoder)
69{
70 struct drm_device *dev = to_drm_encoder(encoder)->dev;
71 struct drm_connector *drm_connector;
72
73 list_for_each_entry(drm_connector, &dev->mode_config.connector_list, head) {
74 if (drm_connector->encoder == to_drm_encoder(encoder))
75 return nouveau_connector(drm_connector);
76 }
77
78 return NULL;
79}
80
62acdc71
BS		 81/*TODO: This could use improvement, and learn to handle the fixed
82 * BIOS tables etc. It's fine currently, for its only user.
83 */
84int
85nouveau_connector_bpp(struct drm_connector *connector)
86{
87 struct nouveau_connector *nv_connector = nouveau_connector(connector);
88
89 if (nv_connector->edid && nv_connector->edid->revision >= 4) {
90 u8 bpc = ((nv_connector->edid->input & 0x70) >> 3) + 4;
91 if (bpc > 4)
92 return bpc;
93 }
94
95 return 18;
96}
6ee73861
BS		 97
98static void
fce2bad0 99nouveau_connector_destroy(struct drm_connector *connector)
6ee73861 100{
fce2bad0
BS		 101 struct nouveau_connector *nv_connector = nouveau_connector(connector);
102 struct drm_nouveau_private *dev_priv;
103 struct nouveau_gpio_engine *pgpio;
dd19e44b 104 struct drm_device *dev;
6ee73861 105
c8ebe275 106 if (!nv_connector)
6ee73861
BS		 107 return;
108
dd19e44b 109 dev = nv_connector->base.dev;
fce2bad0 110 dev_priv = dev->dev_private;
dd19e44b
MS		 111 NV_DEBUG_KMS(dev, "\n");
112
fce2bad0
BS		 113 pgpio = &dev_priv->engine.gpio;
114 if (pgpio->irq_unregister) {
115 pgpio->irq_unregister(dev, nv_connector->dcb->gpio_tag,
116 nouveau_connector_hotplug, connector);
117 }
118
7eae3efa
MG		 119 if (connector->connector_type == DRM_MODE_CONNECTOR_LVDS ||
120 connector->connector_type == DRM_MODE_CONNECTOR_eDP)
121 nouveau_backlight_exit(connector);
122
c8ebe275 123 kfree(nv_connector->edid);
fce2bad0
BS		 124 drm_sysfs_connector_remove(connector);
125 drm_connector_cleanup(connector);
126 kfree(connector);
6ee73861
BS		 127}
128
6ee73861
BS		 129static struct nouveau_i2c_chan *
130nouveau_connector_ddc_detect(struct drm_connector *connector,
131 struct nouveau_encoder **pnv_encoder)
132{
133 struct drm_device *dev = connector->dev;
03cd06ca 134 int i;
6ee73861 135
6ee73861 136 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
4ca2b712 137 struct nouveau_i2c_chan *i2c = NULL;
6ee73861
BS		 138 struct nouveau_encoder *nv_encoder;
139 struct drm_mode_object *obj;
140 int id;
141
142 id = connector->encoder_ids[i];
143 if (!id)
144 break;
145
146 obj = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_ENCODER);
147 if (!obj)
148 continue;
149 nv_encoder = nouveau_encoder(obj_to_encoder(obj));
4ca2b712
FJ		 150
151 if (nv_encoder->dcb->i2c_index < 0xf)
152 i2c = nouveau_i2c_find(dev, nv_encoder->dcb->i2c_index);
6ee73861 153
03cd06ca 154 if (i2c && nouveau_probe_i2c_addr(i2c, 0x50)) {
6ee73861
BS		 155 *pnv_encoder = nv_encoder;
156 return i2c;
157 }
158 }
159
160 return NULL;
161}
162
c16c5707
FJ		 163static struct nouveau_encoder *
164nouveau_connector_of_detect(struct drm_connector *connector)
165{
166#ifdef __powerpc__
167 struct drm_device *dev = connector->dev;
168 struct nouveau_connector *nv_connector = nouveau_connector(connector);
169 struct nouveau_encoder *nv_encoder;
170 struct device_node *cn, *dn = pci_device_to_OF_node(dev->pdev);
171
172 if (!dn ||
173 !((nv_encoder = find_encoder_by_type(connector, OUTPUT_TMDS)) ||
174 (nv_encoder = find_encoder_by_type(connector, OUTPUT_ANALOG))))
175 return NULL;
176
177 for_each_child_of_node(dn, cn) {
178 const char *name = of_get_property(cn, "name", NULL);
179 const void *edid = of_get_property(cn, "EDID", NULL);
180 int idx = name ? name[strlen(name) - 1] - 'A' : 0;
181
182 if (nv_encoder->dcb->i2c_index == idx && edid) {
183 nv_connector->edid =
184 kmemdup(edid, EDID_LENGTH, GFP_KERNEL);
185 of_node_put(cn);
186 return nv_encoder;
187 }
188 }
189#endif
190 return NULL;
191}
192
6ee73861
BS		 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
930a9e28 231nouveau_connector_detect(struct drm_connector *connector, bool force)
6ee73861
BS		 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;
03cd06ca 237 int type;
6ee73861 238
b8780e2a
FJ		 239 /* Cleanup the previous EDID block. */
240 if (nv_connector->edid) {
241 drm_mode_connector_update_edid_property(connector, NULL);
242 kfree(nv_connector->edid);
243 nv_connector->edid = NULL;
244 }
c8ebe275 245
6ee73861
BS		 246 i2c = nouveau_connector_ddc_detect(connector, &nv_encoder);
247 if (i2c) {
6ee73861 248 nv_connector->edid = drm_get_edid(connector, &i2c->adapter);
6ee73861
BS		 249 drm_mode_connector_update_edid_property(connector,
250 nv_connector->edid);
251 if (!nv_connector->edid) {
252 NV_ERROR(dev, "DDC responded, but no EDID for %s\n",
253 drm_get_connector_name(connector));
0ed3165e 254 goto detect_analog;
6ee73861
BS		 255 }
256
257 if (nv_encoder->dcb->type == OUTPUT_DP &&
258 !nouveau_dp_detect(to_drm_encoder(nv_encoder))) {
259 NV_ERROR(dev, "Detected %s, but failed init\n",
260 drm_get_connector_name(connector));
261 return connector_status_disconnected;
262 }
263
264 /* Override encoder type for DVI-I based on whether EDID
265 * says the display is digital or analog, both use the
266 * same i2c channel so the value returned from ddc_detect
267 * isn't necessarily correct.
268 */
be079e97 269 if (nv_connector->dcb->type == DCB_CONNECTOR_DVI_I) {
6ee73861
BS		 270 if (nv_connector->edid->input & DRM_EDID_INPUT_DIGITAL)
271 type = OUTPUT_TMDS;
272 else
273 type = OUTPUT_ANALOG;
274
275 nv_encoder = find_encoder_by_type(connector, type);
276 if (!nv_encoder) {
277 NV_ERROR(dev, "Detected %d encoder on %s, "
278 "but no object!\n", type,
279 drm_get_connector_name(connector));
280 return connector_status_disconnected;
281 }
282 }
283
284 nouveau_connector_set_encoder(connector, nv_encoder);
285 return connector_status_connected;
286 }
287
c16c5707
FJ		 288 nv_encoder = nouveau_connector_of_detect(connector);
289 if (nv_encoder) {
290 nouveau_connector_set_encoder(connector, nv_encoder);
291 return connector_status_connected;
292 }
293
0ed3165e 294detect_analog:
6ee73861 295 nv_encoder = find_encoder_by_type(connector, OUTPUT_ANALOG);
f4053509 296 if (!nv_encoder && !nouveau_tv_disable)
6ee73861 297 nv_encoder = find_encoder_by_type(connector, OUTPUT_TV);
84b8081c 298 if (nv_encoder && force) {
6ee73861
BS		 299 struct drm_encoder *encoder = to_drm_encoder(nv_encoder);
300 struct drm_encoder_helper_funcs *helper =
301 encoder->helper_private;
302
303 if (helper->detect(encoder, connector) ==
304 connector_status_connected) {
305 nouveau_connector_set_encoder(connector, nv_encoder);
306 return connector_status_connected;
307 }
308
309 }
310
311 return connector_status_disconnected;
312}
313
d17f395c 314static enum drm_connector_status
930a9e28 315nouveau_connector_detect_lvds(struct drm_connector *connector, bool force)
d17f395c
BS		 316{
317 struct drm_device *dev = connector->dev;
318 struct drm_nouveau_private *dev_priv = dev->dev_private;
319 struct nouveau_connector *nv_connector = nouveau_connector(connector);
320 struct nouveau_encoder *nv_encoder = NULL;
321 enum drm_connector_status status = connector_status_disconnected;
322
323 /* Cleanup the previous EDID block. */
324 if (nv_connector->edid) {
325 drm_mode_connector_update_edid_property(connector, NULL);
326 kfree(nv_connector->edid);
327 nv_connector->edid = NULL;
328 }
329
330 nv_encoder = find_encoder_by_type(connector, OUTPUT_LVDS);
331 if (!nv_encoder)
332 return connector_status_disconnected;
333
a6ed76d7 334 /* Try retrieving EDID via DDC */
d17f395c 335 if (!dev_priv->vbios.fp_no_ddc) {
930a9e28 336 status = nouveau_connector_detect(connector, force);
d17f395c
BS		 337 if (status == connector_status_connected)
338 goto out;
339 }
340
a6ed76d7
BS		 341 /* On some laptops (Sony, i'm looking at you) there appears to
342 * be no direct way of accessing the panel's EDID. The only
343 * option available to us appears to be to ask ACPI for help..
344 *
345 * It's important this check's before trying straps, one of the
346 * said manufacturer's laptops are configured in such a way
347 * the nouveau decides an entry in the VBIOS FP mode table is
348 * valid - it's not (rh#613284)
349 */
350 if (nv_encoder->dcb->lvdsconf.use_acpi_for_edid) {
351 if (!nouveau_acpi_edid(dev, connector)) {
352 status = connector_status_connected;
353 goto out;
354 }
355 }
356
d17f395c
BS		 357 /* If no EDID found above, and the VBIOS indicates a hardcoded
358 * modeline is avalilable for the panel, set it as the panel's
359 * native mode and exit.
360 */
361 if (nouveau_bios_fp_mode(dev, NULL) && (dev_priv->vbios.fp_no_ddc ||
362 nv_encoder->dcb->lvdsconf.use_straps_for_mode)) {
363 status = connector_status_connected;
364 goto out;
365 }
366
367 /* Still nothing, some VBIOS images have a hardcoded EDID block
368 * stored for the panel stored in them.
369 */
370 if (!dev_priv->vbios.fp_no_ddc) {
371 struct edid *edid =
372 (struct edid *)nouveau_bios_embedded_edid(dev);
373 if (edid) {
374 nv_connector->edid = kmalloc(EDID_LENGTH, GFP_KERNEL);
375 *(nv_connector->edid) = *edid;
376 status = connector_status_connected;
377 }
378 }
379
380out:
381#if defined(CONFIG_ACPI_BUTTON) || \
382 (defined(CONFIG_ACPI_BUTTON_MODULE) && defined(MODULE))
383 if (status == connector_status_connected &&
384 !nouveau_ignorelid && !acpi_lid_open())
385 status = connector_status_unknown;
386#endif
387
388 drm_mode_connector_update_edid_property(connector, nv_connector->edid);
3195c5f9 389 nouveau_connector_set_encoder(connector, nv_encoder);
d17f395c
BS		 390 return status;
391}
392
6ee73861
BS		 393static void
394nouveau_connector_force(struct drm_connector *connector)
395{
be079e97 396 struct nouveau_connector *nv_connector = nouveau_connector(connector);
6ee73861
BS		 397 struct nouveau_encoder *nv_encoder;
398 int type;
399
be079e97 400 if (nv_connector->dcb->type == DCB_CONNECTOR_DVI_I) {
6ee73861
BS		 401 if (connector->force == DRM_FORCE_ON_DIGITAL)
402 type = OUTPUT_TMDS;
403 else
404 type = OUTPUT_ANALOG;
405 } else
406 type = OUTPUT_ANY;
407
408 nv_encoder = find_encoder_by_type(connector, type);
409 if (!nv_encoder) {
be079e97 410 NV_ERROR(connector->dev, "can't find encoder to force %s on!\n",
6ee73861
BS		 411 drm_get_connector_name(connector));
412 connector->status = connector_status_disconnected;
413 return;
414 }
415
416 nouveau_connector_set_encoder(connector, nv_encoder);
417}
418
419static int
420nouveau_connector_set_property(struct drm_connector *connector,
421 struct drm_property *property, uint64_t value)
422{
423 struct nouveau_connector *nv_connector = nouveau_connector(connector);
424 struct nouveau_encoder *nv_encoder = nv_connector->detected_encoder;
4a9f822f 425 struct drm_encoder *encoder = to_drm_encoder(nv_encoder);
6ee73861
BS		 426 struct drm_device *dev = connector->dev;
427 int ret;
428
429 /* Scaling mode */
430 if (property == dev->mode_config.scaling_mode_property) {
431 struct nouveau_crtc *nv_crtc = NULL;
432 bool modeset = false;
433
434 switch (value) {
435 case DRM_MODE_SCALE_NONE:
436 case DRM_MODE_SCALE_FULLSCREEN:
437 case DRM_MODE_SCALE_CENTER:
438 case DRM_MODE_SCALE_ASPECT:
439 break;
440 default:
441 return -EINVAL;
442 }
443
444 /* LVDS always needs gpu scaling */
be079e97 445 if (nv_connector->dcb->type == DCB_CONNECTOR_LVDS &&
6ee73861
BS		 446 value == DRM_MODE_SCALE_NONE)
447 return -EINVAL;
448
449 /* Changing between GPU and panel scaling requires a full
450 * modeset
451 */
452 if ((nv_connector->scaling_mode == DRM_MODE_SCALE_NONE) ||
453 (value == DRM_MODE_SCALE_NONE))
454 modeset = true;
455 nv_connector->scaling_mode = value;
456
457 if (connector->encoder && connector->encoder->crtc)
458 nv_crtc = nouveau_crtc(connector->encoder->crtc);
459 if (!nv_crtc)
460 return 0;
461
462 if (modeset || !nv_crtc->set_scale) {
463 ret = drm_crtc_helper_set_mode(&nv_crtc->base,
464 &nv_crtc->base.mode,
465 nv_crtc->base.x,
466 nv_crtc->base.y, NULL);
467 if (!ret)
468 return -EINVAL;
469 } else {
470 ret = nv_crtc->set_scale(nv_crtc, value, true);
471 if (ret)
472 return ret;
473 }
474
475 return 0;
476 }
477
478 /* Dithering */
479 if (property == dev->mode_config.dithering_mode_property) {
480 struct nouveau_crtc *nv_crtc = NULL;
481
482 if (value == DRM_MODE_DITHERING_ON)
483 nv_connector->use_dithering = true;
484 else
485 nv_connector->use_dithering = false;
486
487 if (connector->encoder && connector->encoder->crtc)
488 nv_crtc = nouveau_crtc(connector->encoder->crtc);
489
490 if (!nv_crtc || !nv_crtc->set_dither)
491 return 0;
492
493 return nv_crtc->set_dither(nv_crtc, nv_connector->use_dithering,
494 true);
495 }
496
497 if (nv_encoder && nv_encoder->dcb->type == OUTPUT_TV)
4a9f822f
FJ		 498 return get_slave_funcs(encoder)->set_property(
499 encoder, connector, property, value);
6ee73861
BS		 500
501 return -EINVAL;
502}
503
504static struct drm_display_mode *
26099a74 505nouveau_connector_native_mode(struct drm_connector *connector)
6ee73861 506{
26099a74
BS		 507 struct drm_connector_helper_funcs *helper = connector->helper_private;
508 struct nouveau_connector *nv_connector = nouveau_connector(connector);
509 struct drm_device *dev = connector->dev;
6ee73861
BS		 510 struct drm_display_mode *mode, *largest = NULL;
511 int high_w = 0, high_h = 0, high_v = 0;
512
26099a74 513 list_for_each_entry(mode, &nv_connector->base.probed_modes, head) {
0d9b6193 514 mode->vrefresh = drm_mode_vrefresh(mode);
a5afb775
FJ		 515 if (helper->mode_valid(connector, mode) != MODE_OK ||
516 (mode->flags & DRM_MODE_FLAG_INTERLACE))
26099a74
BS		 517 continue;
518
519 /* Use preferred mode if there is one.. */
6ee73861 520 if (mode->type & DRM_MODE_TYPE_PREFERRED) {
ef2bb506 521 NV_DEBUG_KMS(dev, "native mode from preferred\n");
6ee73861
BS		 522 return drm_mode_duplicate(dev, mode);
523 }
6ee73861 524
26099a74
BS		 525 /* Otherwise, take the resolution with the largest width, then
526 * height, then vertical refresh
527 */
6ee73861
BS		 528 if (mode->hdisplay < high_w)
529 continue;
530
531 if (mode->hdisplay == high_w && mode->vdisplay < high_h)
532 continue;
533
534 if (mode->hdisplay == high_w && mode->vdisplay == high_h &&
535 mode->vrefresh < high_v)
536 continue;
537
538 high_w = mode->hdisplay;
539 high_h = mode->vdisplay;
540 high_v = mode->vrefresh;
541 largest = mode;
542 }
543
ef2bb506 544 NV_DEBUG_KMS(dev, "native mode from largest: %dx%d@%d\n",
6ee73861
BS		 545 high_w, high_h, high_v);
546 return largest ? drm_mode_duplicate(dev, largest) : NULL;
547}
548
549struct moderec {
550 int hdisplay;
551 int vdisplay;
552};
553
554static struct moderec scaler_modes[] = {
555 { 1920, 1200 },
556 { 1920, 1080 },
557 { 1680, 1050 },
558 { 1600, 1200 },
559 { 1400, 1050 },
560 { 1280, 1024 },
561 { 1280, 960 },
562 { 1152, 864 },
563 { 1024, 768 },
564 { 800, 600 },
565 { 720, 400 },
566 { 640, 480 },
567 { 640, 400 },
568 { 640, 350 },
569 {}
570};
571
572static int
573nouveau_connector_scaler_modes_add(struct drm_connector *connector)
574{
575 struct nouveau_connector *nv_connector = nouveau_connector(connector);
576 struct drm_display_mode *native = nv_connector->native_mode, *m;
577 struct drm_device *dev = connector->dev;
578 struct moderec *mode = &scaler_modes[0];
579 int modes = 0;
580
581 if (!native)
582 return 0;
583
584 while (mode->hdisplay) {
585 if (mode->hdisplay <= native->hdisplay &&
586 mode->vdisplay <= native->vdisplay) {
587 m = drm_cvt_mode(dev, mode->hdisplay, mode->vdisplay,
588 drm_mode_vrefresh(native), false,
589 false, false);
590 if (!m)
591 continue;
592
593 m->type |= DRM_MODE_TYPE_DRIVER;
594
595 drm_mode_probed_add(connector, m);
596 modes++;
597 }
598
599 mode++;
600 }
601
602 return modes;
603}
604
605static int
606nouveau_connector_get_modes(struct drm_connector *connector)
607{
608 struct drm_device *dev = connector->dev;
d17f395c 609 struct drm_nouveau_private *dev_priv = dev->dev_private;
6ee73861
BS		 610 struct nouveau_connector *nv_connector = nouveau_connector(connector);
611 struct nouveau_encoder *nv_encoder = nv_connector->detected_encoder;
4a9f822f 612 struct drm_encoder *encoder = to_drm_encoder(nv_encoder);
6ee73861
BS		 613 int ret = 0;
614
d17f395c 615 /* destroy the native mode, the attached monitor could have changed.
6ee73861 616 */
d17f395c 617 if (nv_connector->native_mode) {
6ee73861
BS		 618 drm_mode_destroy(dev, nv_connector->native_mode);
619 nv_connector->native_mode = NULL;
620 }
621
622 if (nv_connector->edid)
623 ret = drm_add_edid_modes(connector, nv_connector->edid);
d17f395c
BS		 624 else
625 if (nv_encoder->dcb->type == OUTPUT_LVDS &&
626 (nv_encoder->dcb->lvdsconf.use_straps_for_mode ||
6e86e041 627 dev_priv->vbios.fp_no_ddc) && nouveau_bios_fp_mode(dev, NULL)) {
80dad869
BS		 628 struct drm_display_mode mode;
629
630 nouveau_bios_fp_mode(dev, &mode);
631 nv_connector->native_mode = drm_mode_duplicate(dev, &mode);
d17f395c 632 }
6ee73861
BS		 633
634 /* Find the native mode if this is a digital panel, if we didn't
635 * find any modes through DDC previously add the native mode to
636 * the list of modes.
637 */
638 if (!nv_connector->native_mode)
639 nv_connector->native_mode =
26099a74 640 nouveau_connector_native_mode(connector);
6ee73861
BS		 641 if (ret == 0 && nv_connector->native_mode) {
642 struct drm_display_mode *mode;
643
644 mode = drm_mode_duplicate(dev, nv_connector->native_mode);
645 drm_mode_probed_add(connector, mode);
646 ret = 1;
647 }
648
649 if (nv_encoder->dcb->type == OUTPUT_TV)
4a9f822f 650 ret = get_slave_funcs(encoder)->get_modes(encoder, connector);
6ee73861 651
646bef2d
BS		 652 if (nv_connector->dcb->type == DCB_CONNECTOR_LVDS ||
653 nv_connector->dcb->type == DCB_CONNECTOR_eDP)
6ee73861
BS		 654 ret += nouveau_connector_scaler_modes_add(connector);
655
656 return ret;
657}
658
1f5bd443
FJ		 659static unsigned
660get_tmds_link_bandwidth(struct drm_connector *connector)
661{
662 struct nouveau_connector *nv_connector = nouveau_connector(connector);
663 struct drm_nouveau_private *dev_priv = connector->dev->dev_private;
664 struct dcb_entry *dcb = nv_connector->detected_encoder->dcb;
665
666 if (dcb->location != DCB_LOC_ON_CHIP ||
667 dev_priv->chipset >= 0x46)
668 return 165000;
669 else if (dev_priv->chipset >= 0x40)
670 return 155000;
671 else if (dev_priv->chipset >= 0x18)
672 return 135000;
673 else
674 return 112000;
675}
676
6ee73861
BS		 677static int
678nouveau_connector_mode_valid(struct drm_connector *connector,
679 struct drm_display_mode *mode)
680{
6ee73861
BS		 681 struct nouveau_connector *nv_connector = nouveau_connector(connector);
682 struct nouveau_encoder *nv_encoder = nv_connector->detected_encoder;
4a9f822f 683 struct drm_encoder *encoder = to_drm_encoder(nv_encoder);
6ee73861
BS		 684 unsigned min_clock = 25000, max_clock = min_clock;
685 unsigned clock = mode->clock;
686
687 switch (nv_encoder->dcb->type) {
688 case OUTPUT_LVDS:
26099a74
BS		 689 if (nv_connector->native_mode &&
690 (mode->hdisplay > nv_connector->native_mode->hdisplay ||
691 mode->vdisplay > nv_connector->native_mode->vdisplay))
6ee73861
BS		 692 return MODE_PANEL;
693
694 min_clock = 0;
695 max_clock = 400000;
696 break;
697 case OUTPUT_TMDS:
1f5bd443
FJ		 698 max_clock = get_tmds_link_bandwidth(connector);
699 if (nouveau_duallink && nv_encoder->dcb->duallink_possible)
700 max_clock *= 2;
6ee73861
BS		 701 break;
702 case OUTPUT_ANALOG:
703 max_clock = nv_encoder->dcb->crtconf.maxfreq;
704 if (!max_clock)
705 max_clock = 350000;
706 break;
707 case OUTPUT_TV:
4a9f822f 708 return get_slave_funcs(encoder)->mode_valid(encoder, mode);
6ee73861
BS		 709 case OUTPUT_DP:
710 if (nv_encoder->dp.link_bw == DP_LINK_BW_2_7)
711 max_clock = nv_encoder->dp.link_nr * 270000;
712 else
713 max_clock = nv_encoder->dp.link_nr * 162000;
714
62acdc71 715 clock = clock * nouveau_connector_bpp(connector) / 8;
6ee73861 716 break;
e7cc51c5
BS		 717 default:
718 BUG_ON(1);
719 return MODE_BAD;
6ee73861
BS		 720 }
721
722 if (clock < min_clock)
723 return MODE_CLOCK_LOW;
724
725 if (clock > max_clock)
726 return MODE_CLOCK_HIGH;
727
728 return MODE_OK;
729}
730
731static struct drm_encoder *
732nouveau_connector_best_encoder(struct drm_connector *connector)
733{
734 struct nouveau_connector *nv_connector = nouveau_connector(connector);
735
736 if (nv_connector->detected_encoder)
737 return to_drm_encoder(nv_connector->detected_encoder);
738
739 return NULL;
740}
741
742static const struct drm_connector_helper_funcs
743nouveau_connector_helper_funcs = {
744 .get_modes = nouveau_connector_get_modes,
745 .mode_valid = nouveau_connector_mode_valid,
746 .best_encoder = nouveau_connector_best_encoder,
747};
748
749static const struct drm_connector_funcs
750nouveau_connector_funcs = {
751 .dpms = drm_helper_connector_dpms,
752 .save = NULL,
753 .restore = NULL,
754 .detect = nouveau_connector_detect,
755 .destroy = nouveau_connector_destroy,
756 .fill_modes = drm_helper_probe_single_connector_modes,
757 .set_property = nouveau_connector_set_property,
758 .force = nouveau_connector_force
759};
760
d17f395c
BS		 761static const struct drm_connector_funcs
762nouveau_connector_funcs_lvds = {
763 .dpms = drm_helper_connector_dpms,
764 .save = NULL,
765 .restore = NULL,
766 .detect = nouveau_connector_detect_lvds,
767 .destroy = nouveau_connector_destroy,
768 .fill_modes = drm_helper_probe_single_connector_modes,
769 .set_property = nouveau_connector_set_property,
770 .force = nouveau_connector_force
771};
6ee73861 772
8f1a6086
BS		 773struct drm_connector *
774nouveau_connector_create(struct drm_device *dev, int index)
6ee73861 775{
d17f395c 776 const struct drm_connector_funcs *funcs = &nouveau_connector_funcs;
6ee73861 777 struct drm_nouveau_private *dev_priv = dev->dev_private;
fce2bad0 778 struct nouveau_gpio_engine *pgpio = &dev_priv->engine.gpio;
6ee73861 779 struct nouveau_connector *nv_connector = NULL;
8f1a6086 780 struct dcb_connector_table_entry *dcb = NULL;
6ee73861 781 struct drm_connector *connector;
2fa67f12 782 int type, ret = 0;
6ee73861 783
ef2bb506 784 NV_DEBUG_KMS(dev, "\n");
6ee73861 785
8f1a6086
BS		 786 if (index >= dev_priv->vbios.dcb.connector.entries)
787 return ERR_PTR(-EINVAL);
788
789 dcb = &dev_priv->vbios.dcb.connector.entry[index];
790 if (dcb->drm)
791 return dcb->drm;
792
7f612d87 793 switch (dcb->type) {
7f612d87 794 case DCB_CONNECTOR_VGA:
7f612d87 795 type = DRM_MODE_CONNECTOR_VGA;
6ee73861 796 break;
7f612d87
BS		 797 case DCB_CONNECTOR_TV_0:
798 case DCB_CONNECTOR_TV_1:
799 case DCB_CONNECTOR_TV_3:
7f612d87 800 type = DRM_MODE_CONNECTOR_TV;
6ee73861 801 break;
7f612d87 802 case DCB_CONNECTOR_DVI_I:
7f612d87 803 type = DRM_MODE_CONNECTOR_DVII;
6ee73861 804 break;
7f612d87 805 case DCB_CONNECTOR_DVI_D:
7f612d87 806 type = DRM_MODE_CONNECTOR_DVID;
6ee73861 807 break;
be079e97
BS		 808 case DCB_CONNECTOR_HDMI_0:
809 case DCB_CONNECTOR_HDMI_1:
be079e97
BS		 810 type = DRM_MODE_CONNECTOR_HDMIA;
811 break;
7f612d87 812 case DCB_CONNECTOR_LVDS:
7f612d87 813 type = DRM_MODE_CONNECTOR_LVDS;
d17f395c 814 funcs = &nouveau_connector_funcs_lvds;
6ee73861 815 break;
7f612d87 816 case DCB_CONNECTOR_DP:
7f612d87 817 type = DRM_MODE_CONNECTOR_DisplayPort;
6ee73861 818 break;
be079e97 819 case DCB_CONNECTOR_eDP:
be079e97
BS		 820 type = DRM_MODE_CONNECTOR_eDP;
821 break;
6ee73861 822 default:
7f612d87 823 NV_ERROR(dev, "unknown connector type: 0x%02x!!\n", dcb->type);
8f1a6086 824 return ERR_PTR(-EINVAL);
6ee73861
BS		 825 }
826
7f612d87
BS		 827 nv_connector = kzalloc(sizeof(*nv_connector), GFP_KERNEL);
828 if (!nv_connector)
8f1a6086 829 return ERR_PTR(-ENOMEM);
7f612d87
BS		 830 nv_connector->dcb = dcb;
831 connector = &nv_connector->base;
832
6ee73861
BS		 833 /* defaults, will get overridden in detect() */
834 connector->interlace_allowed = false;
835 connector->doublescan_allowed = false;
836
d17f395c 837 drm_connector_init(dev, connector, funcs, type);
6ee73861
BS		 838 drm_connector_helper_add(connector, &nouveau_connector_helper_funcs);
839
2fa67f12
FJ		 840 /* Check if we need dithering enabled */
841 if (dcb->type == DCB_CONNECTOR_LVDS) {
842 bool dummy, is_24bit = false;
843
844 ret = nouveau_bios_parse_lvds_table(dev, 0, &dummy, &is_24bit);
845 if (ret) {
846 NV_ERROR(dev, "Error parsing LVDS table, disabling "
847 "LVDS\n");
848 goto fail;
849 }
850
851 nv_connector->use_dithering = !is_24bit;
7f612d87
BS		 852 }
853
6ee73861 854 /* Init DVI-I specific properties */
be079e97 855 if (dcb->type == DCB_CONNECTOR_DVI_I) {
6ee73861
BS		 856 drm_mode_create_dvi_i_properties(dev);
857 drm_connector_attach_property(connector, dev->mode_config.dvi_i_subconnector_property, 0);
858 drm_connector_attach_property(connector, dev->mode_config.dvi_i_select_subconnector_property, 0);
859 }
860
be079e97
BS		 861 switch (dcb->type) {
862 case DCB_CONNECTOR_VGA:
863 if (dev_priv->card_type >= NV_50) {
6ee73861
BS		 864 drm_connector_attach_property(connector,
865 dev->mode_config.scaling_mode_property,
866 nv_connector->scaling_mode);
867 }
84b8081c 868 connector->polled = DRM_CONNECTOR_POLL_CONNECT;
be079e97
BS		 869 /* fall-through */
870 case DCB_CONNECTOR_TV_0:
871 case DCB_CONNECTOR_TV_1:
872 case DCB_CONNECTOR_TV_3:
873 nv_connector->scaling_mode = DRM_MODE_SCALE_NONE;
874 break;
875 default:
876 nv_connector->scaling_mode = DRM_MODE_SCALE_FULLSCREEN;
877
878 drm_connector_attach_property(connector,
879 dev->mode_config.scaling_mode_property,
880 nv_connector->scaling_mode);
881 drm_connector_attach_property(connector,
882 dev->mode_config.dithering_mode_property,
883 nv_connector->use_dithering ?
884 DRM_MODE_DITHERING_ON : DRM_MODE_DITHERING_OFF);
01db3639 885
06ef3e61
FJ		 886 if (dcb->type != DCB_CONNECTOR_LVDS) {
887 if (dev_priv->card_type >= NV_50)
888 connector->polled = DRM_CONNECTOR_POLL_HPD;
889 else
890 connector->polled = DRM_CONNECTOR_POLL_CONNECT;
891 }
be079e97 892 break;
6ee73861
BS		 893 }
894
fce2bad0
BS		 895 if (pgpio->irq_register) {
896 pgpio->irq_register(dev, nv_connector->dcb->gpio_tag,
897 nouveau_connector_hotplug, connector);
898 }
899
6ee73861 900 drm_sysfs_connector_add(connector);
7eae3efa
MG		 901
902 if (connector->connector_type == DRM_MODE_CONNECTOR_LVDS ||
903 connector->connector_type == DRM_MODE_CONNECTOR_eDP)
904 nouveau_backlight_init(connector);
905
8f1a6086
BS		 906 dcb->drm = connector;
907 return dcb->drm;
2fa67f12
FJ		 908
909fail:
910 drm_connector_cleanup(connector);
911 kfree(connector);
8f1a6086 912 return ERR_PTR(ret);
2fa67f12 913
6ee73861 914}
fce2bad0
BS		 915
916static void
917nouveau_connector_hotplug(void *data, int plugged)
918{
919 struct drm_connector *connector = data;
920 struct drm_device *dev = connector->dev;
921
922 NV_INFO(dev, "%splugged %s\n", plugged ? "" : "un",
923 drm_get_connector_name(connector));
924
925 if (connector->encoder && connector->encoder->crtc &&
926 connector->encoder->crtc->enabled) {
927 struct nouveau_encoder *nv_encoder = nouveau_encoder(connector->encoder);
928 struct drm_encoder_helper_funcs *helper =
929 connector->encoder->helper_private;
930
931 if (nv_encoder->dcb->type == OUTPUT_DP) {
932 if (plugged)
933 helper->dpms(connector->encoder, DRM_MODE_DPMS_ON);
934 else
935 helper->dpms(connector->encoder, DRM_MODE_DPMS_OFF);
936 }
937 }
938
939 drm_helper_hpd_irq_event(dev);
940}
Linux 6.x block layer and io_uring tree(s)