projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
drm/nouveau: no need to pass parameters into set_scale/dither
[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
10b461e4 42struct nouveau_encoder *
e19b20bb 43find_encoder(struct drm_connector *connector, int type)
6ee73861
BS		 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
c8ebe275 119 kfree(nv_connector->edid);
fce2bad0
BS		 120 drm_sysfs_connector_remove(connector);
121 drm_connector_cleanup(connector);
122 kfree(connector);
6ee73861
BS		 123}
124
6ee73861
BS		 125static struct nouveau_i2c_chan *
126nouveau_connector_ddc_detect(struct drm_connector *connector,
127 struct nouveau_encoder **pnv_encoder)
128{
129 struct drm_device *dev = connector->dev;
03cd06ca 130 int i;
6ee73861 131
6ee73861 132 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
4ca2b712 133 struct nouveau_i2c_chan *i2c = NULL;
6ee73861
BS		 134 struct nouveau_encoder *nv_encoder;
135 struct drm_mode_object *obj;
136 int id;
137
138 id = connector->encoder_ids[i];
139 if (!id)
140 break;
141
142 obj = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_ENCODER);
143 if (!obj)
144 continue;
145 nv_encoder = nouveau_encoder(obj_to_encoder(obj));
4ca2b712
FJ		 146
147 if (nv_encoder->dcb->i2c_index < 0xf)
148 i2c = nouveau_i2c_find(dev, nv_encoder->dcb->i2c_index);
6ee73861 149
03cd06ca 150 if (i2c && nouveau_probe_i2c_addr(i2c, 0x50)) {
6ee73861
BS		 151 *pnv_encoder = nv_encoder;
152 return i2c;
153 }
154 }
155
156 return NULL;
157}
158
c16c5707
FJ		 159static struct nouveau_encoder *
160nouveau_connector_of_detect(struct drm_connector *connector)
161{
162#ifdef __powerpc__
163 struct drm_device *dev = connector->dev;
164 struct nouveau_connector *nv_connector = nouveau_connector(connector);
165 struct nouveau_encoder *nv_encoder;
166 struct device_node *cn, *dn = pci_device_to_OF_node(dev->pdev);
167
168 if (!dn ||
e19b20bb
BS		 169 !((nv_encoder = find_encoder(connector, OUTPUT_TMDS)) ||
170 (nv_encoder = find_encoder(connector, OUTPUT_ANALOG))))
c16c5707
FJ		 171 return NULL;
172
173 for_each_child_of_node(dn, cn) {
174 const char *name = of_get_property(cn, "name", NULL);
175 const void *edid = of_get_property(cn, "EDID", NULL);
176 int idx = name ? name[strlen(name) - 1] - 'A' : 0;
177
178 if (nv_encoder->dcb->i2c_index == idx && edid) {
179 nv_connector->edid =
180 kmemdup(edid, EDID_LENGTH, GFP_KERNEL);
181 of_node_put(cn);
182 return nv_encoder;
183 }
184 }
185#endif
186 return NULL;
187}
188
6ee73861
BS		 189static void
190nouveau_connector_set_encoder(struct drm_connector *connector,
191 struct nouveau_encoder *nv_encoder)
192{
193 struct nouveau_connector *nv_connector = nouveau_connector(connector);
194 struct drm_nouveau_private *dev_priv = connector->dev->dev_private;
195 struct drm_device *dev = connector->dev;
196
197 if (nv_connector->detected_encoder == nv_encoder)
198 return;
199 nv_connector->detected_encoder = nv_encoder;
200
201 if (nv_encoder->dcb->type == OUTPUT_LVDS ||
202 nv_encoder->dcb->type == OUTPUT_TMDS) {
203 connector->doublescan_allowed = false;
204 connector->interlace_allowed = false;
205 } else {
206 connector->doublescan_allowed = true;
207 if (dev_priv->card_type == NV_20 ||
208 (dev_priv->card_type == NV_10 &&
209 (dev->pci_device & 0x0ff0) != 0x0100 &&
210 (dev->pci_device & 0x0ff0) != 0x0150))
211 /* HW is broken */
212 connector->interlace_allowed = false;
213 else
214 connector->interlace_allowed = true;
215 }
216
be079e97 217 if (nv_connector->dcb->type == DCB_CONNECTOR_DVI_I) {
6ee73861
BS		 218 drm_connector_property_set_value(connector,
219 dev->mode_config.dvi_i_subconnector_property,
220 nv_encoder->dcb->type == OUTPUT_TMDS ?
221 DRM_MODE_SUBCONNECTOR_DVID :
222 DRM_MODE_SUBCONNECTOR_DVIA);
223 }
224}
225
226static enum drm_connector_status
930a9e28 227nouveau_connector_detect(struct drm_connector *connector, bool force)
6ee73861
BS		 228{
229 struct drm_device *dev = connector->dev;
230 struct nouveau_connector *nv_connector = nouveau_connector(connector);
231 struct nouveau_encoder *nv_encoder = NULL;
e19b20bb 232 struct nouveau_encoder *nv_partner;
6ee73861 233 struct nouveau_i2c_chan *i2c;
03cd06ca 234 int type;
6ee73861 235
b8780e2a
FJ		 236 /* Cleanup the previous EDID block. */
237 if (nv_connector->edid) {
238 drm_mode_connector_update_edid_property(connector, NULL);
239 kfree(nv_connector->edid);
240 nv_connector->edid = NULL;
241 }
c8ebe275 242
6ee73861
BS		 243 i2c = nouveau_connector_ddc_detect(connector, &nv_encoder);
244 if (i2c) {
6ee73861 245 nv_connector->edid = drm_get_edid(connector, &i2c->adapter);
6ee73861
BS		 246 drm_mode_connector_update_edid_property(connector,
247 nv_connector->edid);
248 if (!nv_connector->edid) {
249 NV_ERROR(dev, "DDC responded, but no EDID for %s\n",
250 drm_get_connector_name(connector));
0ed3165e 251 goto detect_analog;
6ee73861
BS		 252 }
253
254 if (nv_encoder->dcb->type == OUTPUT_DP &&
255 !nouveau_dp_detect(to_drm_encoder(nv_encoder))) {
256 NV_ERROR(dev, "Detected %s, but failed init\n",
257 drm_get_connector_name(connector));
258 return connector_status_disconnected;
259 }
260
261 /* Override encoder type for DVI-I based on whether EDID
262 * says the display is digital or analog, both use the
263 * same i2c channel so the value returned from ddc_detect
264 * isn't necessarily correct.
265 */
e19b20bb
BS		 266 nv_partner = NULL;
267 if (nv_encoder->dcb->type == OUTPUT_TMDS)
268 nv_partner = find_encoder(connector, OUTPUT_ANALOG);
269 if (nv_encoder->dcb->type == OUTPUT_ANALOG)
270 nv_partner = find_encoder(connector, OUTPUT_TMDS);
271
272 if (nv_partner && ((nv_encoder->dcb->type == OUTPUT_ANALOG &&
273 nv_partner->dcb->type == OUTPUT_TMDS) ||
274 (nv_encoder->dcb->type == OUTPUT_TMDS &&
275 nv_partner->dcb->type == OUTPUT_ANALOG))) {
6ee73861
BS		 276 if (nv_connector->edid->input & DRM_EDID_INPUT_DIGITAL)
277 type = OUTPUT_TMDS;
278 else
279 type = OUTPUT_ANALOG;
280
e19b20bb 281 nv_encoder = find_encoder(connector, type);
6ee73861
BS		 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:
e19b20bb 295 nv_encoder = find_encoder(connector, OUTPUT_ANALOG);
f4053509 296 if (!nv_encoder && !nouveau_tv_disable)
e19b20bb 297 nv_encoder = find_encoder(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
e19b20bb 330 nv_encoder = find_encoder(connector, OUTPUT_LVDS);
d17f395c
BS		 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
e19b20bb 408 nv_encoder = find_encoder(connector, type);
6ee73861 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{
b29caa58
BS		 423 struct drm_nouveau_private *dev_priv = connector->dev->dev_private;
424 struct nouveau_display_engine *disp = &dev_priv->engine.display;
6ee73861
BS		 425 struct nouveau_connector *nv_connector = nouveau_connector(connector);
426 struct nouveau_encoder *nv_encoder = nv_connector->detected_encoder;
4a9f822f 427 struct drm_encoder *encoder = to_drm_encoder(nv_encoder);
6ee73861 428 struct drm_device *dev = connector->dev;
b29caa58 429 struct nouveau_crtc *nv_crtc;
6ee73861
BS		 430 int ret;
431
b29caa58
BS		 432 nv_crtc = NULL;
433 if (connector->encoder && connector->encoder->crtc)
434 nv_crtc = nouveau_crtc(connector->encoder->crtc);
435
6ee73861
BS		 436 /* Scaling mode */
437 if (property == dev->mode_config.scaling_mode_property) {
6ee73861
BS		 438 bool modeset = false;
439
440 switch (value) {
441 case DRM_MODE_SCALE_NONE:
442 case DRM_MODE_SCALE_FULLSCREEN:
443 case DRM_MODE_SCALE_CENTER:
444 case DRM_MODE_SCALE_ASPECT:
445 break;
446 default:
447 return -EINVAL;
448 }
449
450 /* LVDS always needs gpu scaling */
8c3f6bb9 451 if (connector->connector_type == DRM_MODE_CONNECTOR_LVDS &&
6ee73861
BS		 452 value == DRM_MODE_SCALE_NONE)
453 return -EINVAL;
454
455 /* Changing between GPU and panel scaling requires a full
456 * modeset
457 */
458 if ((nv_connector->scaling_mode == DRM_MODE_SCALE_NONE) ||
459 (value == DRM_MODE_SCALE_NONE))
460 modeset = true;
461 nv_connector->scaling_mode = value;
462
6ee73861
BS		 463 if (!nv_crtc)
464 return 0;
465
466 if (modeset || !nv_crtc->set_scale) {
467 ret = drm_crtc_helper_set_mode(&nv_crtc->base,
468 &nv_crtc->base.mode,
469 nv_crtc->base.x,
470 nv_crtc->base.y, NULL);
471 if (!ret)
472 return -EINVAL;
473 } else {
488ff207 474 ret = nv_crtc->set_scale(nv_crtc, true);
6ee73861
BS		 475 if (ret)
476 return ret;
477 }
478
479 return 0;
480 }
481
b29caa58
BS		 482 /* Underscan */
483 if (property == disp->underscan_property) {
484 if (nv_connector->underscan != value) {
485 nv_connector->underscan = value;
486 if (!nv_crtc || !nv_crtc->set_scale)
487 return 0;
488
488ff207 489 return nv_crtc->set_scale(nv_crtc, true);
b29caa58
BS		 490 }
491
492 return 0;
493 }
494
495 if (property == disp->underscan_hborder_property) {
496 if (nv_connector->underscan_hborder != value) {
497 nv_connector->underscan_hborder = value;
498 if (!nv_crtc || !nv_crtc->set_scale)
499 return 0;
500
488ff207 501 return nv_crtc->set_scale(nv_crtc, true);
b29caa58
BS		 502 }
503
504 return 0;
505 }
506
507 if (property == disp->underscan_vborder_property) {
508 if (nv_connector->underscan_vborder != value) {
509 nv_connector->underscan_vborder = value;
510 if (!nv_crtc || !nv_crtc->set_scale)
511 return 0;
512
488ff207 513 return nv_crtc->set_scale(nv_crtc, true);
b29caa58
BS		 514 }
515
516 return 0;
517 }
518
6ee73861
BS		 519 /* Dithering */
520 if (property == dev->mode_config.dithering_mode_property) {
6ee73861
BS		 521 if (value == DRM_MODE_DITHERING_ON)
522 nv_connector->use_dithering = true;
523 else
524 nv_connector->use_dithering = false;
525
6ee73861
BS		 526 if (!nv_crtc || !nv_crtc->set_dither)
527 return 0;
528
488ff207 529 return nv_crtc->set_dither(nv_crtc, true);
6ee73861
BS		 530 }
531
532 if (nv_encoder && nv_encoder->dcb->type == OUTPUT_TV)
4a9f822f
FJ		 533 return get_slave_funcs(encoder)->set_property(
534 encoder, connector, property, value);
6ee73861
BS		 535
536 return -EINVAL;
537}
538
539static struct drm_display_mode *
26099a74 540nouveau_connector_native_mode(struct drm_connector *connector)
6ee73861 541{
26099a74
BS		 542 struct drm_connector_helper_funcs *helper = connector->helper_private;
543 struct nouveau_connector *nv_connector = nouveau_connector(connector);
544 struct drm_device *dev = connector->dev;
6ee73861
BS		 545 struct drm_display_mode *mode, *largest = NULL;
546 int high_w = 0, high_h = 0, high_v = 0;
547
26099a74 548 list_for_each_entry(mode, &nv_connector->base.probed_modes, head) {
0d9b6193 549 mode->vrefresh = drm_mode_vrefresh(mode);
a5afb775
FJ		 550 if (helper->mode_valid(connector, mode) != MODE_OK ||
551 (mode->flags & DRM_MODE_FLAG_INTERLACE))
26099a74
BS		 552 continue;
553
554 /* Use preferred mode if there is one.. */
6ee73861 555 if (mode->type & DRM_MODE_TYPE_PREFERRED) {
ef2bb506 556 NV_DEBUG_KMS(dev, "native mode from preferred\n");
6ee73861
BS		 557 return drm_mode_duplicate(dev, mode);
558 }
6ee73861 559
26099a74
BS		 560 /* Otherwise, take the resolution with the largest width, then
561 * height, then vertical refresh
562 */
6ee73861
BS		 563 if (mode->hdisplay < high_w)
564 continue;
565
566 if (mode->hdisplay == high_w && mode->vdisplay < high_h)
567 continue;
568
569 if (mode->hdisplay == high_w && mode->vdisplay == high_h &&
570 mode->vrefresh < high_v)
571 continue;
572
573 high_w = mode->hdisplay;
574 high_h = mode->vdisplay;
575 high_v = mode->vrefresh;
576 largest = mode;
577 }
578
ef2bb506 579 NV_DEBUG_KMS(dev, "native mode from largest: %dx%d@%d\n",
6ee73861
BS		 580 high_w, high_h, high_v);
581 return largest ? drm_mode_duplicate(dev, largest) : NULL;
582}
583
584struct moderec {
585 int hdisplay;
586 int vdisplay;
587};
588
589static struct moderec scaler_modes[] = {
590 { 1920, 1200 },
591 { 1920, 1080 },
592 { 1680, 1050 },
593 { 1600, 1200 },
594 { 1400, 1050 },
595 { 1280, 1024 },
596 { 1280, 960 },
597 { 1152, 864 },
598 { 1024, 768 },
599 { 800, 600 },
600 { 720, 400 },
601 { 640, 480 },
602 { 640, 400 },
603 { 640, 350 },
604 {}
605};
606
607static int
608nouveau_connector_scaler_modes_add(struct drm_connector *connector)
609{
610 struct nouveau_connector *nv_connector = nouveau_connector(connector);
611 struct drm_display_mode *native = nv_connector->native_mode, *m;
612 struct drm_device *dev = connector->dev;
613 struct moderec *mode = &scaler_modes[0];
614 int modes = 0;
615
616 if (!native)
617 return 0;
618
619 while (mode->hdisplay) {
620 if (mode->hdisplay <= native->hdisplay &&
621 mode->vdisplay <= native->vdisplay) {
622 m = drm_cvt_mode(dev, mode->hdisplay, mode->vdisplay,
623 drm_mode_vrefresh(native), false,
624 false, false);
625 if (!m)
626 continue;
627
628 m->type |= DRM_MODE_TYPE_DRIVER;
629
630 drm_mode_probed_add(connector, m);
631 modes++;
632 }
633
634 mode++;
635 }
636
637 return modes;
638}
639
63221755
BS		 640static void
641nouveau_connector_detect_depth(struct drm_connector *connector)
642{
643 struct drm_nouveau_private *dev_priv = connector->dev->dev_private;
644 struct nouveau_connector *nv_connector = nouveau_connector(connector);
645 struct nouveau_encoder *nv_encoder = nv_connector->detected_encoder;
646 struct nvbios *bios = &dev_priv->vbios;
647 struct drm_display_mode *mode = nv_connector->native_mode;
648 bool duallink;
649
650 /* if the edid is feeling nice enough to provide this info, use it */
651 if (nv_connector->edid && connector->display_info.bpc)
652 return;
653
654 /* if not, we're out of options unless we're LVDS, default to 6bpc */
655 connector->display_info.bpc = 6;
656 if (nv_encoder->dcb->type != OUTPUT_LVDS)
657 return;
658
659 /* LVDS: panel straps */
660 if (bios->fp_no_ddc) {
661 if (bios->fp.if_is_24bit)
662 connector->display_info.bpc = 8;
663 return;
664 }
665
666 /* LVDS: DDC panel, need to first determine the number of links to
667 * know which if_is_24bit flag to check...
668 */
669 if (nv_connector->edid &&
670 nv_connector->dcb->type == DCB_CONNECTOR_LVDS_SPWG)
671 duallink = ((u8 *)nv_connector->edid)[121] == 2;
672 else
673 duallink = mode->clock >= bios->fp.duallink_transition_clk;
674
675 if ((!duallink && (bios->fp.strapless_is_24bit & 1)) ||
676 ( duallink && (bios->fp.strapless_is_24bit & 2)))
677 connector->display_info.bpc = 8;
678}
679
6ee73861
BS		 680static int
681nouveau_connector_get_modes(struct drm_connector *connector)
682{
683 struct drm_device *dev = connector->dev;
d17f395c 684 struct drm_nouveau_private *dev_priv = dev->dev_private;
6ee73861
BS		 685 struct nouveau_connector *nv_connector = nouveau_connector(connector);
686 struct nouveau_encoder *nv_encoder = nv_connector->detected_encoder;
4a9f822f 687 struct drm_encoder *encoder = to_drm_encoder(nv_encoder);
6ee73861
BS		 688 int ret = 0;
689
d17f395c 690 /* destroy the native mode, the attached monitor could have changed.
6ee73861 691 */
d17f395c 692 if (nv_connector->native_mode) {
6ee73861
BS		 693 drm_mode_destroy(dev, nv_connector->native_mode);
694 nv_connector->native_mode = NULL;
695 }
696
697 if (nv_connector->edid)
698 ret = drm_add_edid_modes(connector, nv_connector->edid);
d17f395c
BS		 699 else
700 if (nv_encoder->dcb->type == OUTPUT_LVDS &&
701 (nv_encoder->dcb->lvdsconf.use_straps_for_mode ||
6e86e041 702 dev_priv->vbios.fp_no_ddc) && nouveau_bios_fp_mode(dev, NULL)) {
80dad869
BS		 703 struct drm_display_mode mode;
704
705 nouveau_bios_fp_mode(dev, &mode);
706 nv_connector->native_mode = drm_mode_duplicate(dev, &mode);
d17f395c 707 }
6ee73861
BS		 708
709 /* Find the native mode if this is a digital panel, if we didn't
710 * find any modes through DDC previously add the native mode to
711 * the list of modes.
712 */
713 if (!nv_connector->native_mode)
714 nv_connector->native_mode =
26099a74 715 nouveau_connector_native_mode(connector);
6ee73861
BS		 716 if (ret == 0 && nv_connector->native_mode) {
717 struct drm_display_mode *mode;
718
719 mode = drm_mode_duplicate(dev, nv_connector->native_mode);
720 drm_mode_probed_add(connector, mode);
721 ret = 1;
722 }
723
63221755
BS		 724 /* Attempt to determine display colour depth, this has to happen after
725 * we've determined the "native" mode for LVDS, as the VBIOS tables
726 * require us to compare against a pixel clock in some cases..
727 */
728 nouveau_connector_detect_depth(connector);
729
6ee73861 730 if (nv_encoder->dcb->type == OUTPUT_TV)
4a9f822f 731 ret = get_slave_funcs(encoder)->get_modes(encoder, connector);
6ee73861 732
646bef2d 733 if (nv_connector->dcb->type == DCB_CONNECTOR_LVDS ||
8c3f6bb9 734 nv_connector->dcb->type == DCB_CONNECTOR_LVDS_SPWG ||
646bef2d 735 nv_connector->dcb->type == DCB_CONNECTOR_eDP)
6ee73861
BS		 736 ret += nouveau_connector_scaler_modes_add(connector);
737
738 return ret;
739}
740
1f5bd443
FJ		 741static unsigned
742get_tmds_link_bandwidth(struct drm_connector *connector)
743{
744 struct nouveau_connector *nv_connector = nouveau_connector(connector);
745 struct drm_nouveau_private *dev_priv = connector->dev->dev_private;
746 struct dcb_entry *dcb = nv_connector->detected_encoder->dcb;
747
748 if (dcb->location != DCB_LOC_ON_CHIP ||
749 dev_priv->chipset >= 0x46)
750 return 165000;
751 else if (dev_priv->chipset >= 0x40)
752 return 155000;
753 else if (dev_priv->chipset >= 0x18)
754 return 135000;
755 else
756 return 112000;
757}
758
6ee73861
BS		 759static int
760nouveau_connector_mode_valid(struct drm_connector *connector,
761 struct drm_display_mode *mode)
762{
6ee73861
BS		 763 struct nouveau_connector *nv_connector = nouveau_connector(connector);
764 struct nouveau_encoder *nv_encoder = nv_connector->detected_encoder;
4a9f822f 765 struct drm_encoder *encoder = to_drm_encoder(nv_encoder);
6ee73861
BS		 766 unsigned min_clock = 25000, max_clock = min_clock;
767 unsigned clock = mode->clock;
768
769 switch (nv_encoder->dcb->type) {
770 case OUTPUT_LVDS:
26099a74
BS		 771 if (nv_connector->native_mode &&
772 (mode->hdisplay > nv_connector->native_mode->hdisplay ||
773 mode->vdisplay > nv_connector->native_mode->vdisplay))
6ee73861
BS		 774 return MODE_PANEL;
775
776 min_clock = 0;
777 max_clock = 400000;
778 break;
779 case OUTPUT_TMDS:
1f5bd443
FJ		 780 max_clock = get_tmds_link_bandwidth(connector);
781 if (nouveau_duallink && nv_encoder->dcb->duallink_possible)
782 max_clock *= 2;
6ee73861
BS		 783 break;
784 case OUTPUT_ANALOG:
785 max_clock = nv_encoder->dcb->crtconf.maxfreq;
786 if (!max_clock)
787 max_clock = 350000;
788 break;
789 case OUTPUT_TV:
4a9f822f 790 return get_slave_funcs(encoder)->mode_valid(encoder, mode);
6ee73861 791 case OUTPUT_DP:
75a1fccf
BS		 792 max_clock = nv_encoder->dp.link_nr;
793 max_clock *= nv_encoder->dp.link_bw;
5c79507b 794 clock = clock * nouveau_connector_bpp(connector) / 10;
6ee73861 795 break;
e7cc51c5
BS		 796 default:
797 BUG_ON(1);
798 return MODE_BAD;
6ee73861
BS		 799 }
800
801 if (clock < min_clock)
802 return MODE_CLOCK_LOW;
803
804 if (clock > max_clock)
805 return MODE_CLOCK_HIGH;
806
807 return MODE_OK;
808}
809
810static struct drm_encoder *
811nouveau_connector_best_encoder(struct drm_connector *connector)
812{
813 struct nouveau_connector *nv_connector = nouveau_connector(connector);
814
815 if (nv_connector->detected_encoder)
816 return to_drm_encoder(nv_connector->detected_encoder);
817
818 return NULL;
819}
820
821static const struct drm_connector_helper_funcs
822nouveau_connector_helper_funcs = {
823 .get_modes = nouveau_connector_get_modes,
824 .mode_valid = nouveau_connector_mode_valid,
825 .best_encoder = nouveau_connector_best_encoder,
826};
827
828static const struct drm_connector_funcs
829nouveau_connector_funcs = {
830 .dpms = drm_helper_connector_dpms,
831 .save = NULL,
832 .restore = NULL,
833 .detect = nouveau_connector_detect,
834 .destroy = nouveau_connector_destroy,
835 .fill_modes = drm_helper_probe_single_connector_modes,
836 .set_property = nouveau_connector_set_property,
837 .force = nouveau_connector_force
838};
839
d17f395c
BS		 840static const struct drm_connector_funcs
841nouveau_connector_funcs_lvds = {
842 .dpms = drm_helper_connector_dpms,
843 .save = NULL,
844 .restore = NULL,
845 .detect = nouveau_connector_detect_lvds,
846 .destroy = nouveau_connector_destroy,
847 .fill_modes = drm_helper_probe_single_connector_modes,
848 .set_property = nouveau_connector_set_property,
849 .force = nouveau_connector_force
850};
6ee73861 851
8f1a6086
BS		 852struct drm_connector *
853nouveau_connector_create(struct drm_device *dev, int index)
6ee73861 854{
d17f395c 855 const struct drm_connector_funcs *funcs = &nouveau_connector_funcs;
6ee73861 856 struct drm_nouveau_private *dev_priv = dev->dev_private;
b29caa58 857 struct nouveau_display_engine *disp = &dev_priv->engine.display;
fce2bad0 858 struct nouveau_gpio_engine *pgpio = &dev_priv->engine.gpio;
6ee73861 859 struct nouveau_connector *nv_connector = NULL;
8f1a6086 860 struct dcb_connector_table_entry *dcb = NULL;
6ee73861 861 struct drm_connector *connector;
2fa67f12 862 int type, ret = 0;
6ee73861 863
ef2bb506 864 NV_DEBUG_KMS(dev, "\n");
6ee73861 865
8f1a6086
BS		 866 if (index >= dev_priv->vbios.dcb.connector.entries)
867 return ERR_PTR(-EINVAL);
868
869 dcb = &dev_priv->vbios.dcb.connector.entry[index];
870 if (dcb->drm)
871 return dcb->drm;
872
7f612d87 873 switch (dcb->type) {
7f612d87 874 case DCB_CONNECTOR_VGA:
7f612d87 875 type = DRM_MODE_CONNECTOR_VGA;
6ee73861 876 break;
7f612d87
BS		 877 case DCB_CONNECTOR_TV_0:
878 case DCB_CONNECTOR_TV_1:
879 case DCB_CONNECTOR_TV_3:
7f612d87 880 type = DRM_MODE_CONNECTOR_TV;
6ee73861 881 break;
7f612d87 882 case DCB_CONNECTOR_DVI_I:
7f612d87 883 type = DRM_MODE_CONNECTOR_DVII;
6ee73861 884 break;
7f612d87 885 case DCB_CONNECTOR_DVI_D:
7f612d87 886 type = DRM_MODE_CONNECTOR_DVID;
6ee73861 887 break;
be079e97
BS		 888 case DCB_CONNECTOR_HDMI_0:
889 case DCB_CONNECTOR_HDMI_1:
be079e97
BS		 890 type = DRM_MODE_CONNECTOR_HDMIA;
891 break;
7f612d87 892 case DCB_CONNECTOR_LVDS:
8c3f6bb9 893 case DCB_CONNECTOR_LVDS_SPWG:
7f612d87 894 type = DRM_MODE_CONNECTOR_LVDS;
d17f395c 895 funcs = &nouveau_connector_funcs_lvds;
6ee73861 896 break;
7f612d87 897 case DCB_CONNECTOR_DP:
7f612d87 898 type = DRM_MODE_CONNECTOR_DisplayPort;
6ee73861 899 break;
be079e97 900 case DCB_CONNECTOR_eDP:
be079e97
BS		 901 type = DRM_MODE_CONNECTOR_eDP;
902 break;
6ee73861 903 default:
7f612d87 904 NV_ERROR(dev, "unknown connector type: 0x%02x!!\n", dcb->type);
8f1a6086 905 return ERR_PTR(-EINVAL);
6ee73861
BS		 906 }
907
7f612d87
BS		 908 nv_connector = kzalloc(sizeof(*nv_connector), GFP_KERNEL);
909 if (!nv_connector)
8f1a6086 910 return ERR_PTR(-ENOMEM);
7f612d87
BS		 911 nv_connector->dcb = dcb;
912 connector = &nv_connector->base;
913
6ee73861
BS		 914 /* defaults, will get overridden in detect() */
915 connector->interlace_allowed = false;
916 connector->doublescan_allowed = false;
917
d17f395c 918 drm_connector_init(dev, connector, funcs, type);
6ee73861
BS		 919 drm_connector_helper_add(connector, &nouveau_connector_helper_funcs);
920
2fa67f12 921 /* Check if we need dithering enabled */
8c3f6bb9 922 if (connector->connector_type == DRM_MODE_CONNECTOR_LVDS) {
2fa67f12
FJ		 923 bool dummy, is_24bit = false;
924
925 ret = nouveau_bios_parse_lvds_table(dev, 0, &dummy, &is_24bit);
926 if (ret) {
927 NV_ERROR(dev, "Error parsing LVDS table, disabling "
928 "LVDS\n");
929 goto fail;
930 }
931
932 nv_connector->use_dithering = !is_24bit;
7f612d87
BS		 933 }
934
6ee73861 935 /* Init DVI-I specific properties */
be079e97 936 if (dcb->type == DCB_CONNECTOR_DVI_I) {
6ee73861
BS		 937 drm_mode_create_dvi_i_properties(dev);
938 drm_connector_attach_property(connector, dev->mode_config.dvi_i_subconnector_property, 0);
939 drm_connector_attach_property(connector, dev->mode_config.dvi_i_select_subconnector_property, 0);
940 }
941
b29caa58
BS		 942 /* Add overscan compensation options to digital outputs */
943 if ((dev_priv->card_type == NV_50 ||
944 dev_priv->card_type == NV_C0) &&
945 (dcb->type == DCB_CONNECTOR_DVI_D ||
946 dcb->type == DCB_CONNECTOR_DVI_I ||
947 dcb->type == DCB_CONNECTOR_HDMI_0 ||
948 dcb->type == DCB_CONNECTOR_HDMI_1 ||
949 dcb->type == DCB_CONNECTOR_DP)) {
950 drm_connector_attach_property(connector,
951 disp->underscan_property,
952 UNDERSCAN_OFF);
953 drm_connector_attach_property(connector,
954 disp->underscan_hborder_property,
955 0);
956 drm_connector_attach_property(connector,
957 disp->underscan_vborder_property,
958 0);
959 }
960
be079e97
BS		 961 switch (dcb->type) {
962 case DCB_CONNECTOR_VGA:
963 if (dev_priv->card_type >= NV_50) {
6ee73861
BS		 964 drm_connector_attach_property(connector,
965 dev->mode_config.scaling_mode_property,
966 nv_connector->scaling_mode);
967 }
be079e97
BS		 968 /* fall-through */
969 case DCB_CONNECTOR_TV_0:
970 case DCB_CONNECTOR_TV_1:
971 case DCB_CONNECTOR_TV_3:
972 nv_connector->scaling_mode = DRM_MODE_SCALE_NONE;
973 break;
974 default:
975 nv_connector->scaling_mode = DRM_MODE_SCALE_FULLSCREEN;
976
977 drm_connector_attach_property(connector,
978 dev->mode_config.scaling_mode_property,
979 nv_connector->scaling_mode);
980 drm_connector_attach_property(connector,
981 dev->mode_config.dithering_mode_property,
982 nv_connector->use_dithering ?
983 DRM_MODE_DITHERING_ON : DRM_MODE_DITHERING_OFF);
984 break;
6ee73861
BS		 985 }
986
1cb70b30 987 if (nv_connector->dcb->gpio_tag != 0xff && pgpio->irq_register) {
fce2bad0
BS		 988 pgpio->irq_register(dev, nv_connector->dcb->gpio_tag,
989 nouveau_connector_hotplug, connector);
1cb70b30
BS		 990
991 connector->polled = DRM_CONNECTOR_POLL_HPD;
992 } else {
993 connector->polled = DRM_CONNECTOR_POLL_CONNECT;
fce2bad0
BS		 994 }
995
6ee73861 996 drm_sysfs_connector_add(connector);
7eae3efa 997
8f1a6086
BS		 998 dcb->drm = connector;
999 return dcb->drm;
2fa67f12
FJ		 1000
1001fail:
1002 drm_connector_cleanup(connector);
1003 kfree(connector);
8f1a6086 1004 return ERR_PTR(ret);
2fa67f12 1005
6ee73861 1006}
fce2bad0
BS		 1007
1008static void
1009nouveau_connector_hotplug(void *data, int plugged)
1010{
1011 struct drm_connector *connector = data;
1012 struct drm_device *dev = connector->dev;
1013
68c99184
BS		 1014 NV_DEBUG(dev, "%splugged %s\n", plugged ? "" : "un",
1015 drm_get_connector_name(connector));
fce2bad0 1016
68c99184
BS		 1017 if (plugged)
1018 drm_helper_connector_dpms(connector, DRM_MODE_DPMS_ON);
1019 else
1020 drm_helper_connector_dpms(connector, DRM_MODE_DPMS_OFF);
fce2bad0
BS		 1021
1022 drm_helper_hpd_irq_event(dev);
1023}
Linux 6.x block layer and io_uring tree(s)