1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27#include <acpi/button.h>
28
29#include <linux/pm_runtime.h>
30#include <linux/vga_switcheroo.h>
31
32#include <drm/drm_atomic_helper.h>
33#include <drm/drm_edid.h>
34#include <drm/drm_crtc_helper.h>
35#include <drm/drm_probe_helper.h>
36#include <drm/drm_atomic.h>
37
38#include "nouveau_reg.h"
39#include "nouveau_drv.h"
40#include "dispnv04/hw.h"
41#include "dispnv50/disp.h"
42#include "nouveau_acpi.h"
43
44#include "nouveau_display.h"
45#include "nouveau_connector.h"
46#include "nouveau_encoder.h"
47#include "nouveau_crtc.h"
48
49#include <nvif/class.h>
50#include <nvif/cl0046.h>
51#include <nvif/event.h>
52
53struct drm_display_mode *
54nouveau_conn_native_mode(struct drm_connector *connector)
55{
56 const struct drm_connector_helper_funcs *helper = connector->helper_private;
57 struct nouveau_drm *drm = nouveau_drm(connector->dev);
58 struct drm_device *dev = connector->dev;
59 struct drm_display_mode *mode, *largest = NULL;
60 int high_w = 0, high_h = 0, high_v = 0;
61
62 list_for_each_entry(mode, &connector->probed_modes, head) {
63 mode->vrefresh = drm_mode_vrefresh(mode);
64 if (helper->mode_valid(connector, mode) != MODE_OK ||
65 (mode->flags & DRM_MODE_FLAG_INTERLACE))
66 continue;
67
68
69 if (mode->type & DRM_MODE_TYPE_PREFERRED) {
70 NV_DEBUG(drm, "native mode from preferred\n");
71 return drm_mode_duplicate(dev, mode);
72 }
73
74
75
76
77 if (mode->hdisplay < high_w)
78 continue;
79
80 if (mode->hdisplay == high_w && mode->vdisplay < high_h)
81 continue;
82
83 if (mode->hdisplay == high_w && mode->vdisplay == high_h &&
84 mode->vrefresh < high_v)
85 continue;
86
87 high_w = mode->hdisplay;
88 high_h = mode->vdisplay;
89 high_v = mode->vrefresh;
90 largest = mode;
91 }
92
93 NV_DEBUG(drm, "native mode from largest: %dx%d@%d\n",
94 high_w, high_h, high_v);
95 return largest ? drm_mode_duplicate(dev, largest) : NULL;
96}
97
98int
99nouveau_conn_atomic_get_property(struct drm_connector *connector,
100 const struct drm_connector_state *state,
101 struct drm_property *property, u64 *val)
102{
103 struct nouveau_conn_atom *asyc = nouveau_conn_atom(state);
104 struct nouveau_display *disp = nouveau_display(connector->dev);
105 struct drm_device *dev = connector->dev;
106
107 if (property == dev->mode_config.scaling_mode_property)
108 *val = asyc->scaler.mode;
109 else if (property == disp->underscan_property)
110 *val = asyc->scaler.underscan.mode;
111 else if (property == disp->underscan_hborder_property)
112 *val = asyc->scaler.underscan.hborder;
113 else if (property == disp->underscan_vborder_property)
114 *val = asyc->scaler.underscan.vborder;
115 else if (property == disp->dithering_mode)
116 *val = asyc->dither.mode;
117 else if (property == disp->dithering_depth)
118 *val = asyc->dither.depth;
119 else if (property == disp->vibrant_hue_property)
120 *val = asyc->procamp.vibrant_hue;
121 else if (property == disp->color_vibrance_property)
122 *val = asyc->procamp.color_vibrance;
123 else
124 return -EINVAL;
125
126 return 0;
127}
128
129int
130nouveau_conn_atomic_set_property(struct drm_connector *connector,
131 struct drm_connector_state *state,
132 struct drm_property *property, u64 val)
133{
134 struct drm_device *dev = connector->dev;
135 struct nouveau_conn_atom *asyc = nouveau_conn_atom(state);
136 struct nouveau_display *disp = nouveau_display(dev);
137
138 if (property == dev->mode_config.scaling_mode_property) {
139 switch (val) {
140 case DRM_MODE_SCALE_NONE:
141
142
143
144
145
146
147
148
149 switch (connector->connector_type) {
150 case DRM_MODE_CONNECTOR_LVDS:
151 case DRM_MODE_CONNECTOR_eDP:
152
153
154
155 if (disp->disp.object.oclass < NV50_DISP)
156 return -EINVAL;
157 break;
158 default:
159 break;
160 }
161 case DRM_MODE_SCALE_FULLSCREEN:
162 case DRM_MODE_SCALE_CENTER:
163 case DRM_MODE_SCALE_ASPECT:
164 break;
165 default:
166 return -EINVAL;
167 }
168
169 if (asyc->scaler.mode != val) {
170 asyc->scaler.mode = val;
171 asyc->set.scaler = true;
172 }
173 } else
174 if (property == disp->underscan_property) {
175 if (asyc->scaler.underscan.mode != val) {
176 asyc->scaler.underscan.mode = val;
177 asyc->set.scaler = true;
178 }
179 } else
180 if (property == disp->underscan_hborder_property) {
181 if (asyc->scaler.underscan.hborder != val) {
182 asyc->scaler.underscan.hborder = val;
183 asyc->set.scaler = true;
184 }
185 } else
186 if (property == disp->underscan_vborder_property) {
187 if (asyc->scaler.underscan.vborder != val) {
188 asyc->scaler.underscan.vborder = val;
189 asyc->set.scaler = true;
190 }
191 } else
192 if (property == disp->dithering_mode) {
193 if (asyc->dither.mode != val) {
194 asyc->dither.mode = val;
195 asyc->set.dither = true;
196 }
197 } else
198 if (property == disp->dithering_depth) {
199 if (asyc->dither.mode != val) {
200 asyc->dither.depth = val;
201 asyc->set.dither = true;
202 }
203 } else
204 if (property == disp->vibrant_hue_property) {
205 if (asyc->procamp.vibrant_hue != val) {
206 asyc->procamp.vibrant_hue = val;
207 asyc->set.procamp = true;
208 }
209 } else
210 if (property == disp->color_vibrance_property) {
211 if (asyc->procamp.color_vibrance != val) {
212 asyc->procamp.color_vibrance = val;
213 asyc->set.procamp = true;
214 }
215 } else {
216 return -EINVAL;
217 }
218
219 return 0;
220}
221
222void
223nouveau_conn_atomic_destroy_state(struct drm_connector *connector,
224 struct drm_connector_state *state)
225{
226 struct nouveau_conn_atom *asyc = nouveau_conn_atom(state);
227 __drm_atomic_helper_connector_destroy_state(&asyc->state);
228 kfree(asyc);
229}
230
231struct drm_connector_state *
232nouveau_conn_atomic_duplicate_state(struct drm_connector *connector)
233{
234 struct nouveau_conn_atom *armc = nouveau_conn_atom(connector->state);
235 struct nouveau_conn_atom *asyc;
236 if (!(asyc = kmalloc(sizeof(*asyc), GFP_KERNEL)))
237 return NULL;
238 __drm_atomic_helper_connector_duplicate_state(connector, &asyc->state);
239 asyc->dither = armc->dither;
240 asyc->scaler = armc->scaler;
241 asyc->procamp = armc->procamp;
242 asyc->set.mask = 0;
243 return &asyc->state;
244}
245
246void
247nouveau_conn_reset(struct drm_connector *connector)
248{
249 struct nouveau_connector *nv_connector = nouveau_connector(connector);
250 struct nouveau_conn_atom *asyc;
251
252 if (drm_drv_uses_atomic_modeset(connector->dev)) {
253 if (WARN_ON(!(asyc = kzalloc(sizeof(*asyc), GFP_KERNEL))))
254 return;
255
256 if (connector->state)
257 nouveau_conn_atomic_destroy_state(connector,
258 connector->state);
259
260 __drm_atomic_helper_connector_reset(connector, &asyc->state);
261 } else {
262 asyc = &nv_connector->properties_state;
263 }
264
265 asyc->dither.mode = DITHERING_MODE_AUTO;
266 asyc->dither.depth = DITHERING_DEPTH_AUTO;
267 asyc->scaler.mode = DRM_MODE_SCALE_NONE;
268 asyc->scaler.underscan.mode = UNDERSCAN_OFF;
269 asyc->procamp.color_vibrance = 150;
270 asyc->procamp.vibrant_hue = 90;
271
272 if (nouveau_display(connector->dev)->disp.object.oclass < NV50_DISP) {
273 switch (connector->connector_type) {
274 case DRM_MODE_CONNECTOR_LVDS:
275
276 asyc->scaler.mode = DRM_MODE_SCALE_FULLSCREEN;
277 break;
278 default:
279 break;
280 }
281 }
282}
283
284void
285nouveau_conn_attach_properties(struct drm_connector *connector)
286{
287 struct drm_device *dev = connector->dev;
288 struct nouveau_display *disp = nouveau_display(dev);
289 struct nouveau_connector *nv_connector = nouveau_connector(connector);
290 struct nouveau_conn_atom *armc;
291
292 if (drm_drv_uses_atomic_modeset(connector->dev))
293 armc = nouveau_conn_atom(connector->state);
294 else
295 armc = &nv_connector->properties_state;
296
297
298 if (connector->connector_type == DRM_MODE_CONNECTOR_DVII)
299 drm_object_attach_property(&connector->base, dev->mode_config.
300 dvi_i_subconnector_property, 0);
301
302
303 if (disp->underscan_property &&
304 (connector->connector_type == DRM_MODE_CONNECTOR_DVID ||
305 connector->connector_type == DRM_MODE_CONNECTOR_DVII ||
306 connector->connector_type == DRM_MODE_CONNECTOR_HDMIA ||
307 connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort)) {
308 drm_object_attach_property(&connector->base,
309 disp->underscan_property,
310 UNDERSCAN_OFF);
311 drm_object_attach_property(&connector->base,
312 disp->underscan_hborder_property, 0);
313 drm_object_attach_property(&connector->base,
314 disp->underscan_vborder_property, 0);
315 }
316
317
318 if (disp->vibrant_hue_property)
319 drm_object_attach_property(&connector->base,
320 disp->vibrant_hue_property,
321 armc->procamp.vibrant_hue);
322 if (disp->color_vibrance_property)
323 drm_object_attach_property(&connector->base,
324 disp->color_vibrance_property,
325 armc->procamp.color_vibrance);
326
327
328 switch (connector->connector_type) {
329 case DRM_MODE_CONNECTOR_TV:
330 break;
331 case DRM_MODE_CONNECTOR_VGA:
332 if (disp->disp.object.oclass < NV50_DISP)
333 break;
334
335 default:
336 drm_object_attach_property(&connector->base, dev->mode_config.
337 scaling_mode_property,
338 armc->scaler.mode);
339 break;
340 }
341
342
343 switch (connector->connector_type) {
344 case DRM_MODE_CONNECTOR_TV:
345 case DRM_MODE_CONNECTOR_VGA:
346 break;
347 default:
348 if (disp->dithering_mode) {
349 drm_object_attach_property(&connector->base,
350 disp->dithering_mode,
351 armc->dither.mode);
352 }
353 if (disp->dithering_depth) {
354 drm_object_attach_property(&connector->base,
355 disp->dithering_depth,
356 armc->dither.depth);
357 }
358 break;
359 }
360}
361
362MODULE_PARM_DESC(tv_disable, "Disable TV-out detection");
363int nouveau_tv_disable = 0;
364module_param_named(tv_disable, nouveau_tv_disable, int, 0400);
365
366MODULE_PARM_DESC(ignorelid, "Ignore ACPI lid status");
367int nouveau_ignorelid = 0;
368module_param_named(ignorelid, nouveau_ignorelid, int, 0400);
369
370MODULE_PARM_DESC(duallink, "Allow dual-link TMDS (default: enabled)");
371int nouveau_duallink = 1;
372module_param_named(duallink, nouveau_duallink, int, 0400);
373
374MODULE_PARM_DESC(hdmimhz, "Force a maximum HDMI pixel clock (in MHz)");
375int nouveau_hdmimhz = 0;
376module_param_named(hdmimhz, nouveau_hdmimhz, int, 0400);
377
378struct nouveau_encoder *
379find_encoder(struct drm_connector *connector, int type)
380{
381 struct nouveau_encoder *nv_encoder;
382 struct drm_encoder *enc;
383
384 drm_connector_for_each_possible_encoder(connector, enc) {
385 nv_encoder = nouveau_encoder(enc);
386
387 if (type == DCB_OUTPUT_ANY ||
388 (nv_encoder->dcb && nv_encoder->dcb->type == type))
389 return nv_encoder;
390 }
391
392 return NULL;
393}
394
395struct nouveau_connector *
396nouveau_encoder_connector_get(struct nouveau_encoder *encoder)
397{
398 struct drm_device *dev = to_drm_encoder(encoder)->dev;
399 struct drm_connector *drm_connector;
400
401 list_for_each_entry(drm_connector, &dev->mode_config.connector_list, head) {
402 if (drm_connector->encoder == to_drm_encoder(encoder))
403 return nouveau_connector(drm_connector);
404 }
405
406 return NULL;
407}
408
409static void
410nouveau_connector_destroy(struct drm_connector *connector)
411{
412 struct nouveau_connector *nv_connector = nouveau_connector(connector);
413 nvif_notify_fini(&nv_connector->hpd);
414 kfree(nv_connector->edid);
415 drm_connector_unregister(connector);
416 drm_connector_cleanup(connector);
417 if (nv_connector->aux.transfer) {
418 drm_dp_cec_unregister_connector(&nv_connector->aux);
419 drm_dp_aux_unregister(&nv_connector->aux);
420 kfree(nv_connector->aux.name);
421 }
422 kfree(connector);
423}
424
425static struct nouveau_encoder *
426nouveau_connector_ddc_detect(struct drm_connector *connector)
427{
428 struct drm_device *dev = connector->dev;
429 struct nouveau_encoder *nv_encoder = NULL, *found = NULL;
430 struct drm_encoder *encoder;
431 int ret;
432 bool switcheroo_ddc = false;
433
434 drm_connector_for_each_possible_encoder(connector, encoder) {
435 nv_encoder = nouveau_encoder(encoder);
436
437 switch (nv_encoder->dcb->type) {
438 case DCB_OUTPUT_DP:
439 ret = nouveau_dp_detect(nv_encoder);
440 if (ret == NOUVEAU_DP_MST)
441 return NULL;
442 else if (ret == NOUVEAU_DP_SST)
443 found = nv_encoder;
444
445 break;
446 case DCB_OUTPUT_LVDS:
447 switcheroo_ddc = !!(vga_switcheroo_handler_flags() &
448 VGA_SWITCHEROO_CAN_SWITCH_DDC);
449
450 default:
451 if (!nv_encoder->i2c)
452 break;
453
454 if (switcheroo_ddc)
455 vga_switcheroo_lock_ddc(dev->pdev);
456 if (nvkm_probe_i2c(nv_encoder->i2c, 0x50))
457 found = nv_encoder;
458 if (switcheroo_ddc)
459 vga_switcheroo_unlock_ddc(dev->pdev);
460
461 break;
462 }
463 if (found)
464 break;
465 }
466
467 return found;
468}
469
470static struct nouveau_encoder *
471nouveau_connector_of_detect(struct drm_connector *connector)
472{
473#ifdef __powerpc__
474 struct drm_device *dev = connector->dev;
475 struct nouveau_connector *nv_connector = nouveau_connector(connector);
476 struct nouveau_encoder *nv_encoder;
477 struct device_node *cn, *dn = pci_device_to_OF_node(dev->pdev);
478
479 if (!dn ||
480 !((nv_encoder = find_encoder(connector, DCB_OUTPUT_TMDS)) ||
481 (nv_encoder = find_encoder(connector, DCB_OUTPUT_ANALOG))))
482 return NULL;
483
484 for_each_child_of_node(dn, cn) {
485 const char *name = of_get_property(cn, "name", NULL);
486 const void *edid = of_get_property(cn, "EDID", NULL);
487 int idx = name ? name[strlen(name) - 1] - 'A' : 0;
488
489 if (nv_encoder->dcb->i2c_index == idx && edid) {
490 nv_connector->edid =
491 kmemdup(edid, EDID_LENGTH, GFP_KERNEL);
492 of_node_put(cn);
493 return nv_encoder;
494 }
495 }
496#endif
497 return NULL;
498}
499
500static void
501nouveau_connector_set_encoder(struct drm_connector *connector,
502 struct nouveau_encoder *nv_encoder)
503{
504 struct nouveau_connector *nv_connector = nouveau_connector(connector);
505 struct nouveau_drm *drm = nouveau_drm(connector->dev);
506 struct drm_device *dev = connector->dev;
507
508 if (nv_connector->detected_encoder == nv_encoder)
509 return;
510 nv_connector->detected_encoder = nv_encoder;
511
512 if (drm->client.device.info.family >= NV_DEVICE_INFO_V0_TESLA) {
513 if (nv_encoder->dcb->type == DCB_OUTPUT_DP)
514 connector->interlace_allowed =
515 nv_encoder->caps.dp_interlace;
516 else
517 connector->interlace_allowed = true;
518 connector->doublescan_allowed = true;
519 } else
520 if (nv_encoder->dcb->type == DCB_OUTPUT_LVDS ||
521 nv_encoder->dcb->type == DCB_OUTPUT_TMDS) {
522 connector->doublescan_allowed = false;
523 connector->interlace_allowed = false;
524 } else {
525 connector->doublescan_allowed = true;
526 if (drm->client.device.info.family == NV_DEVICE_INFO_V0_KELVIN ||
527 (drm->client.device.info.family == NV_DEVICE_INFO_V0_CELSIUS &&
528 (dev->pdev->device & 0x0ff0) != 0x0100 &&
529 (dev->pdev->device & 0x0ff0) != 0x0150))
530
531 connector->interlace_allowed = false;
532 else
533 connector->interlace_allowed = true;
534 }
535
536 if (nv_connector->type == DCB_CONNECTOR_DVI_I) {
537 drm_object_property_set_value(&connector->base,
538 dev->mode_config.dvi_i_subconnector_property,
539 nv_encoder->dcb->type == DCB_OUTPUT_TMDS ?
540 DRM_MODE_SUBCONNECTOR_DVID :
541 DRM_MODE_SUBCONNECTOR_DVIA);
542 }
543}
544
545static enum drm_connector_status
546nouveau_connector_detect(struct drm_connector *connector, bool force)
547{
548 struct drm_device *dev = connector->dev;
549 struct nouveau_drm *drm = nouveau_drm(dev);
550 struct nouveau_connector *nv_connector = nouveau_connector(connector);
551 struct nouveau_encoder *nv_encoder = NULL;
552 struct nouveau_encoder *nv_partner;
553 struct i2c_adapter *i2c;
554 int type;
555 int ret;
556 enum drm_connector_status conn_status = connector_status_disconnected;
557
558
559 if (nv_connector->edid) {
560 drm_connector_update_edid_property(connector, NULL);
561 kfree(nv_connector->edid);
562 nv_connector->edid = NULL;
563 }
564
565
566
567
568
569
570
571 if (drm_kms_helper_is_poll_worker()) {
572 pm_runtime_get_noresume(dev->dev);
573 } else {
574 ret = pm_runtime_get_sync(dev->dev);
575 if (ret < 0 && ret != -EACCES)
576 return conn_status;
577 }
578
579 nv_encoder = nouveau_connector_ddc_detect(connector);
580 if (nv_encoder && (i2c = nv_encoder->i2c) != NULL) {
581 if ((vga_switcheroo_handler_flags() &
582 VGA_SWITCHEROO_CAN_SWITCH_DDC) &&
583 nv_connector->type == DCB_CONNECTOR_LVDS)
584 nv_connector->edid = drm_get_edid_switcheroo(connector,
585 i2c);
586 else
587 nv_connector->edid = drm_get_edid(connector, i2c);
588
589 drm_connector_update_edid_property(connector,
590 nv_connector->edid);
591 if (!nv_connector->edid) {
592 NV_ERROR(drm, "DDC responded, but no EDID for %s\n",
593 connector->name);
594 goto detect_analog;
595 }
596
597
598
599
600
601
602 nv_partner = NULL;
603 if (nv_encoder->dcb->type == DCB_OUTPUT_TMDS)
604 nv_partner = find_encoder(connector, DCB_OUTPUT_ANALOG);
605 if (nv_encoder->dcb->type == DCB_OUTPUT_ANALOG)
606 nv_partner = find_encoder(connector, DCB_OUTPUT_TMDS);
607
608 if (nv_partner && ((nv_encoder->dcb->type == DCB_OUTPUT_ANALOG &&
609 nv_partner->dcb->type == DCB_OUTPUT_TMDS) ||
610 (nv_encoder->dcb->type == DCB_OUTPUT_TMDS &&
611 nv_partner->dcb->type == DCB_OUTPUT_ANALOG))) {
612 if (nv_connector->edid->input & DRM_EDID_INPUT_DIGITAL)
613 type = DCB_OUTPUT_TMDS;
614 else
615 type = DCB_OUTPUT_ANALOG;
616
617 nv_encoder = find_encoder(connector, type);
618 }
619
620 nouveau_connector_set_encoder(connector, nv_encoder);
621 conn_status = connector_status_connected;
622 drm_dp_cec_set_edid(&nv_connector->aux, nv_connector->edid);
623 goto out;
624 }
625
626 nv_encoder = nouveau_connector_of_detect(connector);
627 if (nv_encoder) {
628 nouveau_connector_set_encoder(connector, nv_encoder);
629 conn_status = connector_status_connected;
630 goto out;
631 }
632
633detect_analog:
634 nv_encoder = find_encoder(connector, DCB_OUTPUT_ANALOG);
635 if (!nv_encoder && !nouveau_tv_disable)
636 nv_encoder = find_encoder(connector, DCB_OUTPUT_TV);
637 if (nv_encoder && force) {
638 struct drm_encoder *encoder = to_drm_encoder(nv_encoder);
639 const struct drm_encoder_helper_funcs *helper =
640 encoder->helper_private;
641
642 if (helper->detect(encoder, connector) ==
643 connector_status_connected) {
644 nouveau_connector_set_encoder(connector, nv_encoder);
645 conn_status = connector_status_connected;
646 goto out;
647 }
648
649 }
650
651 out:
652
653 pm_runtime_mark_last_busy(dev->dev);
654 pm_runtime_put_autosuspend(dev->dev);
655
656 return conn_status;
657}
658
659static enum drm_connector_status
660nouveau_connector_detect_lvds(struct drm_connector *connector, bool force)
661{
662 struct drm_device *dev = connector->dev;
663 struct nouveau_drm *drm = nouveau_drm(dev);
664 struct nouveau_connector *nv_connector = nouveau_connector(connector);
665 struct nouveau_encoder *nv_encoder = NULL;
666 enum drm_connector_status status = connector_status_disconnected;
667
668
669 if (nv_connector->edid) {
670 drm_connector_update_edid_property(connector, NULL);
671 kfree(nv_connector->edid);
672 nv_connector->edid = NULL;
673 }
674
675 nv_encoder = find_encoder(connector, DCB_OUTPUT_LVDS);
676 if (!nv_encoder)
677 return connector_status_disconnected;
678
679
680 if (!drm->vbios.fp_no_ddc) {
681 status = nouveau_connector_detect(connector, force);
682 if (status == connector_status_connected)
683 goto out;
684 }
685
686
687
688
689
690
691
692
693
694
695 if (nv_encoder->dcb->lvdsconf.use_acpi_for_edid) {
696 if ((nv_connector->edid = nouveau_acpi_edid(dev, connector))) {
697 status = connector_status_connected;
698 goto out;
699 }
700 }
701
702
703
704
705
706 if (nouveau_bios_fp_mode(dev, NULL) && (drm->vbios.fp_no_ddc ||
707 nv_encoder->dcb->lvdsconf.use_straps_for_mode)) {
708 status = connector_status_connected;
709 goto out;
710 }
711
712
713
714
715 if (!drm->vbios.fp_no_ddc) {
716 struct edid *edid =
717 (struct edid *)nouveau_bios_embedded_edid(dev);
718 if (edid) {
719 nv_connector->edid =
720 kmemdup(edid, EDID_LENGTH, GFP_KERNEL);
721 if (nv_connector->edid)
722 status = connector_status_connected;
723 }
724 }
725
726out:
727#if defined(CONFIG_ACPI_BUTTON) || \
728 (defined(CONFIG_ACPI_BUTTON_MODULE) && defined(MODULE))
729 if (status == connector_status_connected &&
730 !nouveau_ignorelid && !acpi_lid_open())
731 status = connector_status_unknown;
732#endif
733
734 drm_connector_update_edid_property(connector, nv_connector->edid);
735 nouveau_connector_set_encoder(connector, nv_encoder);
736 return status;
737}
738
739static void
740nouveau_connector_force(struct drm_connector *connector)
741{
742 struct nouveau_drm *drm = nouveau_drm(connector->dev);
743 struct nouveau_connector *nv_connector = nouveau_connector(connector);
744 struct nouveau_encoder *nv_encoder;
745 int type;
746
747 if (nv_connector->type == DCB_CONNECTOR_DVI_I) {
748 if (connector->force == DRM_FORCE_ON_DIGITAL)
749 type = DCB_OUTPUT_TMDS;
750 else
751 type = DCB_OUTPUT_ANALOG;
752 } else
753 type = DCB_OUTPUT_ANY;
754
755 nv_encoder = find_encoder(connector, type);
756 if (!nv_encoder) {
757 NV_ERROR(drm, "can't find encoder to force %s on!\n",
758 connector->name);
759 connector->status = connector_status_disconnected;
760 return;
761 }
762
763 nouveau_connector_set_encoder(connector, nv_encoder);
764}
765
766static int
767nouveau_connector_set_property(struct drm_connector *connector,
768 struct drm_property *property, uint64_t value)
769{
770 struct nouveau_connector *nv_connector = nouveau_connector(connector);
771 struct nouveau_encoder *nv_encoder = nv_connector->detected_encoder;
772 struct nouveau_conn_atom *asyc = &nv_connector->properties_state;
773 struct drm_encoder *encoder = to_drm_encoder(nv_encoder);
774 int ret;
775
776 ret = connector->funcs->atomic_set_property(&nv_connector->base,
777 &asyc->state,
778 property, value);
779 if (ret) {
780 if (nv_encoder && nv_encoder->dcb->type == DCB_OUTPUT_TV)
781 return get_slave_funcs(encoder)->set_property(
782 encoder, connector, property, value);
783 return ret;
784 }
785
786 nv_connector->scaling_mode = asyc->scaler.mode;
787 nv_connector->dithering_mode = asyc->dither.mode;
788
789 if (connector->encoder && connector->encoder->crtc) {
790 ret = drm_crtc_helper_set_mode(connector->encoder->crtc,
791 &connector->encoder->crtc->mode,
792 connector->encoder->crtc->x,
793 connector->encoder->crtc->y,
794 NULL);
795 if (!ret)
796 return -EINVAL;
797 }
798
799 return 0;
800}
801
802struct moderec {
803 int hdisplay;
804 int vdisplay;
805};
806
807static struct moderec scaler_modes[] = {
808 { 1920, 1200 },
809 { 1920, 1080 },
810 { 1680, 1050 },
811 { 1600, 1200 },
812 { 1400, 1050 },
813 { 1280, 1024 },
814 { 1280, 960 },
815 { 1152, 864 },
816 { 1024, 768 },
817 { 800, 600 },
818 { 720, 400 },
819 { 640, 480 },
820 { 640, 400 },
821 { 640, 350 },
822 {}
823};
824
825static int
826nouveau_connector_scaler_modes_add(struct drm_connector *connector)
827{
828 struct nouveau_connector *nv_connector = nouveau_connector(connector);
829 struct drm_display_mode *native = nv_connector->native_mode, *m;
830 struct drm_device *dev = connector->dev;
831 struct moderec *mode = &scaler_modes[0];
832 int modes = 0;
833
834 if (!native)
835 return 0;
836
837 while (mode->hdisplay) {
838 if (mode->hdisplay <= native->hdisplay &&
839 mode->vdisplay <= native->vdisplay &&
840 (mode->hdisplay != native->hdisplay ||
841 mode->vdisplay != native->vdisplay)) {
842 m = drm_cvt_mode(dev, mode->hdisplay, mode->vdisplay,
843 drm_mode_vrefresh(native), false,
844 false, false);
845 if (!m)
846 continue;
847
848 drm_mode_probed_add(connector, m);
849 modes++;
850 }
851
852 mode++;
853 }
854
855 return modes;
856}
857
858static void
859nouveau_connector_detect_depth(struct drm_connector *connector)
860{
861 struct nouveau_drm *drm = nouveau_drm(connector->dev);
862 struct nouveau_connector *nv_connector = nouveau_connector(connector);
863 struct nouveau_encoder *nv_encoder = nv_connector->detected_encoder;
864 struct nvbios *bios = &drm->vbios;
865 struct drm_display_mode *mode = nv_connector->native_mode;
866 bool duallink;
867
868
869 if (nv_connector->edid && connector->display_info.bpc)
870 return;
871
872
873 if (nv_connector->type == DCB_CONNECTOR_eDP) {
874 connector->display_info.bpc = 6;
875 return;
876 }
877
878
879 if (nv_encoder->dcb->type != DCB_OUTPUT_LVDS) {
880 connector->display_info.bpc = 8;
881 return;
882 }
883
884 connector->display_info.bpc = 6;
885
886
887 if (bios->fp_no_ddc) {
888 if (bios->fp.if_is_24bit)
889 connector->display_info.bpc = 8;
890 return;
891 }
892
893
894
895
896 if (nv_connector->edid &&
897 nv_connector->type == DCB_CONNECTOR_LVDS_SPWG)
898 duallink = ((u8 *)nv_connector->edid)[121] == 2;
899 else
900 duallink = mode->clock >= bios->fp.duallink_transition_clk;
901
902 if ((!duallink && (bios->fp.strapless_is_24bit & 1)) ||
903 ( duallink && (bios->fp.strapless_is_24bit & 2)))
904 connector->display_info.bpc = 8;
905}
906
907static int
908nouveau_connector_late_register(struct drm_connector *connector)
909{
910 int ret;
911
912 ret = nouveau_backlight_init(connector);
913
914 return ret;
915}
916
917static void
918nouveau_connector_early_unregister(struct drm_connector *connector)
919{
920 nouveau_backlight_fini(connector);
921}
922
923static int
924nouveau_connector_get_modes(struct drm_connector *connector)
925{
926 struct drm_device *dev = connector->dev;
927 struct nouveau_drm *drm = nouveau_drm(dev);
928 struct nouveau_connector *nv_connector = nouveau_connector(connector);
929 struct nouveau_encoder *nv_encoder = nv_connector->detected_encoder;
930 struct drm_encoder *encoder = to_drm_encoder(nv_encoder);
931 int ret = 0;
932
933
934
935 if (nv_connector->native_mode) {
936 drm_mode_destroy(dev, nv_connector->native_mode);
937 nv_connector->native_mode = NULL;
938 }
939
940 if (nv_connector->edid)
941 ret = drm_add_edid_modes(connector, nv_connector->edid);
942 else
943 if (nv_encoder->dcb->type == DCB_OUTPUT_LVDS &&
944 (nv_encoder->dcb->lvdsconf.use_straps_for_mode ||
945 drm->vbios.fp_no_ddc) && nouveau_bios_fp_mode(dev, NULL)) {
946 struct drm_display_mode mode;
947
948 nouveau_bios_fp_mode(dev, &mode);
949 nv_connector->native_mode = drm_mode_duplicate(dev, &mode);
950 }
951
952
953
954
955 if (connector->connector_type != DRM_MODE_CONNECTOR_LVDS)
956 nouveau_connector_detect_depth(connector);
957
958
959
960
961
962 if (!nv_connector->native_mode)
963 nv_connector->native_mode = nouveau_conn_native_mode(connector);
964 if (ret == 0 && nv_connector->native_mode) {
965 struct drm_display_mode *mode;
966
967 mode = drm_mode_duplicate(dev, nv_connector->native_mode);
968 drm_mode_probed_add(connector, mode);
969 ret = 1;
970 }
971
972
973
974
975
976 if (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)
977 nouveau_connector_detect_depth(connector);
978
979 if (nv_encoder->dcb->type == DCB_OUTPUT_TV)
980 ret = get_slave_funcs(encoder)->get_modes(encoder, connector);
981
982 if (nv_connector->type == DCB_CONNECTOR_LVDS ||
983 nv_connector->type == DCB_CONNECTOR_LVDS_SPWG ||
984 nv_connector->type == DCB_CONNECTOR_eDP)
985 ret += nouveau_connector_scaler_modes_add(connector);
986
987 return ret;
988}
989
990static unsigned
991get_tmds_link_bandwidth(struct drm_connector *connector)
992{
993 struct nouveau_connector *nv_connector = nouveau_connector(connector);
994 struct nouveau_encoder *nv_encoder = nv_connector->detected_encoder;
995 struct nouveau_drm *drm = nouveau_drm(connector->dev);
996 struct dcb_output *dcb = nv_connector->detected_encoder->dcb;
997 struct drm_display_info *info = NULL;
998 unsigned duallink_scale =
999 nouveau_duallink && nv_encoder->dcb->duallink_possible ? 2 : 1;
1000
1001 if (drm_detect_hdmi_monitor(nv_connector->edid)) {
1002 info = &nv_connector->base.display_info;
1003 duallink_scale = 1;
1004 }
1005
1006 if (info) {
1007 if (nouveau_hdmimhz > 0)
1008 return nouveau_hdmimhz * 1000;
1009
1010
1011
1012 if (drm->client.device.info.chipset >= 0x120) {
1013 const int max_tmds_clock =
1014 info->hdmi.scdc.scrambling.supported ?
1015 594000 : 340000;
1016 return info->max_tmds_clock ?
1017 min(info->max_tmds_clock, max_tmds_clock) :
1018 max_tmds_clock;
1019 }
1020 if (drm->client.device.info.family >= NV_DEVICE_INFO_V0_KEPLER)
1021 return 297000;
1022 if (drm->client.device.info.family >= NV_DEVICE_INFO_V0_FERMI)
1023 return 225000;
1024 }
1025
1026 if (dcb->location != DCB_LOC_ON_CHIP ||
1027 drm->client.device.info.chipset >= 0x46)
1028 return 165000 * duallink_scale;
1029 else if (drm->client.device.info.chipset >= 0x40)
1030 return 155000 * duallink_scale;
1031 else if (drm->client.device.info.chipset >= 0x18)
1032 return 135000 * duallink_scale;
1033 else
1034 return 112000 * duallink_scale;
1035}
1036
1037enum drm_mode_status
1038nouveau_conn_mode_clock_valid(const struct drm_display_mode *mode,
1039 const unsigned min_clock,
1040 const unsigned max_clock,
1041 unsigned int *clock_out)
1042{
1043 unsigned int clock = mode->clock;
1044
1045 if ((mode->flags & DRM_MODE_FLAG_3D_MASK) ==
1046 DRM_MODE_FLAG_3D_FRAME_PACKING)
1047 clock *= 2;
1048
1049 if (clock < min_clock)
1050 return MODE_CLOCK_LOW;
1051 if (clock > max_clock)
1052 return MODE_CLOCK_HIGH;
1053
1054 if (clock_out)
1055 *clock_out = clock;
1056
1057 return MODE_OK;
1058}
1059
1060static enum drm_mode_status
1061nouveau_connector_mode_valid(struct drm_connector *connector,
1062 struct drm_display_mode *mode)
1063{
1064 struct nouveau_connector *nv_connector = nouveau_connector(connector);
1065 struct nouveau_encoder *nv_encoder = nv_connector->detected_encoder;
1066 struct drm_encoder *encoder = to_drm_encoder(nv_encoder);
1067 unsigned min_clock = 25000, max_clock = min_clock;
1068
1069 switch (nv_encoder->dcb->type) {
1070 case DCB_OUTPUT_LVDS:
1071 if (nv_connector->native_mode &&
1072 (mode->hdisplay > nv_connector->native_mode->hdisplay ||
1073 mode->vdisplay > nv_connector->native_mode->vdisplay))
1074 return MODE_PANEL;
1075
1076 min_clock = 0;
1077 max_clock = 400000;
1078 break;
1079 case DCB_OUTPUT_TMDS:
1080 max_clock = get_tmds_link_bandwidth(connector);
1081 break;
1082 case DCB_OUTPUT_ANALOG:
1083 max_clock = nv_encoder->dcb->crtconf.maxfreq;
1084 if (!max_clock)
1085 max_clock = 350000;
1086 break;
1087 case DCB_OUTPUT_TV:
1088 return get_slave_funcs(encoder)->mode_valid(encoder, mode);
1089 case DCB_OUTPUT_DP:
1090 return nv50_dp_mode_valid(connector, nv_encoder, mode, NULL);
1091 default:
1092 BUG();
1093 return MODE_BAD;
1094 }
1095
1096 return nouveau_conn_mode_clock_valid(mode, min_clock, max_clock,
1097 NULL);
1098}
1099
1100static struct drm_encoder *
1101nouveau_connector_best_encoder(struct drm_connector *connector)
1102{
1103 struct nouveau_connector *nv_connector = nouveau_connector(connector);
1104
1105 if (nv_connector->detected_encoder)
1106 return to_drm_encoder(nv_connector->detected_encoder);
1107
1108 return NULL;
1109}
1110
1111static const struct drm_connector_helper_funcs
1112nouveau_connector_helper_funcs = {
1113 .get_modes = nouveau_connector_get_modes,
1114 .mode_valid = nouveau_connector_mode_valid,
1115 .best_encoder = nouveau_connector_best_encoder,
1116};
1117
1118static const struct drm_connector_funcs
1119nouveau_connector_funcs = {
1120 .dpms = drm_helper_connector_dpms,
1121 .reset = nouveau_conn_reset,
1122 .detect = nouveau_connector_detect,
1123 .force = nouveau_connector_force,
1124 .fill_modes = drm_helper_probe_single_connector_modes,
1125 .set_property = nouveau_connector_set_property,
1126 .destroy = nouveau_connector_destroy,
1127 .atomic_duplicate_state = nouveau_conn_atomic_duplicate_state,
1128 .atomic_destroy_state = nouveau_conn_atomic_destroy_state,
1129 .atomic_set_property = nouveau_conn_atomic_set_property,
1130 .atomic_get_property = nouveau_conn_atomic_get_property,
1131 .late_register = nouveau_connector_late_register,
1132 .early_unregister = nouveau_connector_early_unregister,
1133};
1134
1135static const struct drm_connector_funcs
1136nouveau_connector_funcs_lvds = {
1137 .dpms = drm_helper_connector_dpms,
1138 .reset = nouveau_conn_reset,
1139 .detect = nouveau_connector_detect_lvds,
1140 .force = nouveau_connector_force,
1141 .fill_modes = drm_helper_probe_single_connector_modes,
1142 .set_property = nouveau_connector_set_property,
1143 .destroy = nouveau_connector_destroy,
1144 .atomic_duplicate_state = nouveau_conn_atomic_duplicate_state,
1145 .atomic_destroy_state = nouveau_conn_atomic_destroy_state,
1146 .atomic_set_property = nouveau_conn_atomic_set_property,
1147 .atomic_get_property = nouveau_conn_atomic_get_property,
1148 .late_register = nouveau_connector_late_register,
1149 .early_unregister = nouveau_connector_early_unregister,
1150};
1151
1152static int
1153nouveau_connector_hotplug(struct nvif_notify *notify)
1154{
1155 struct nouveau_connector *nv_connector =
1156 container_of(notify, typeof(*nv_connector), hpd);
1157 struct drm_connector *connector = &nv_connector->base;
1158 struct nouveau_drm *drm = nouveau_drm(connector->dev);
1159 const struct nvif_notify_conn_rep_v0 *rep = notify->data;
1160 const char *name = connector->name;
1161 struct nouveau_encoder *nv_encoder;
1162 int ret;
1163 bool plugged = (rep->mask != NVIF_NOTIFY_CONN_V0_UNPLUG);
1164
1165 if (rep->mask & NVIF_NOTIFY_CONN_V0_IRQ) {
1166 NV_DEBUG(drm, "service %s\n", name);
1167 drm_dp_cec_irq(&nv_connector->aux);
1168 if ((nv_encoder = find_encoder(connector, DCB_OUTPUT_DP)))
1169 nv50_mstm_service(nv_encoder->dp.mstm);
1170
1171 return NVIF_NOTIFY_KEEP;
1172 }
1173
1174 ret = pm_runtime_get(drm->dev->dev);
1175 if (ret == 0 || ret == -EINPROGRESS) {
1176
1177
1178
1179
1180
1181 NV_DEBUG(drm, "Deferring HPD on %s until runtime resume\n",
1182 name);
1183 schedule_work(&drm->hpd_work);
1184
1185 pm_runtime_put_noidle(drm->dev->dev);
1186 return NVIF_NOTIFY_KEEP;
1187 } else if (ret != 1 && ret != -EACCES) {
1188 NV_WARN(drm, "HPD on %s dropped due to RPM failure: %d\n",
1189 name, ret);
1190
1191 pm_runtime_mark_last_busy(drm->dev->dev);
1192 pm_runtime_put_autosuspend(drm->dev->dev);
1193 return NVIF_NOTIFY_DROP;
1194 }
1195
1196 if (!plugged)
1197 drm_dp_cec_unset_edid(&nv_connector->aux);
1198 NV_DEBUG(drm, "%splugged %s\n", plugged ? "" : "un", name);
1199 if ((nv_encoder = find_encoder(connector, DCB_OUTPUT_DP))) {
1200 if (!plugged)
1201 nv50_mstm_remove(nv_encoder->dp.mstm);
1202 }
1203
1204 drm_helper_hpd_irq_event(connector->dev);
1205
1206 pm_runtime_mark_last_busy(drm->dev->dev);
1207 pm_runtime_put_autosuspend(drm->dev->dev);
1208 return NVIF_NOTIFY_KEEP;
1209}
1210
1211static ssize_t
1212nouveau_connector_aux_xfer(struct drm_dp_aux *obj, struct drm_dp_aux_msg *msg)
1213{
1214 struct nouveau_connector *nv_connector =
1215 container_of(obj, typeof(*nv_connector), aux);
1216 struct nouveau_encoder *nv_encoder;
1217 struct nvkm_i2c_aux *aux;
1218 u8 size = msg->size;
1219 int ret;
1220
1221 nv_encoder = find_encoder(&nv_connector->base, DCB_OUTPUT_DP);
1222 if (!nv_encoder || !(aux = nv_encoder->aux))
1223 return -ENODEV;
1224 if (WARN_ON(msg->size > 16))
1225 return -E2BIG;
1226
1227 ret = nvkm_i2c_aux_acquire(aux);
1228 if (ret)
1229 return ret;
1230
1231 ret = nvkm_i2c_aux_xfer(aux, false, msg->request, msg->address,
1232 msg->buffer, &size);
1233 nvkm_i2c_aux_release(aux);
1234 if (ret >= 0) {
1235 msg->reply = ret;
1236 return size;
1237 }
1238
1239 return ret;
1240}
1241
1242static int
1243drm_conntype_from_dcb(enum dcb_connector_type dcb)
1244{
1245 switch (dcb) {
1246 case DCB_CONNECTOR_VGA : return DRM_MODE_CONNECTOR_VGA;
1247 case DCB_CONNECTOR_TV_0 :
1248 case DCB_CONNECTOR_TV_1 :
1249 case DCB_CONNECTOR_TV_3 : return DRM_MODE_CONNECTOR_TV;
1250 case DCB_CONNECTOR_DMS59_0 :
1251 case DCB_CONNECTOR_DMS59_1 :
1252 case DCB_CONNECTOR_DVI_I : return DRM_MODE_CONNECTOR_DVII;
1253 case DCB_CONNECTOR_DVI_D : return DRM_MODE_CONNECTOR_DVID;
1254 case DCB_CONNECTOR_LVDS :
1255 case DCB_CONNECTOR_LVDS_SPWG: return DRM_MODE_CONNECTOR_LVDS;
1256 case DCB_CONNECTOR_DMS59_DP0:
1257 case DCB_CONNECTOR_DMS59_DP1:
1258 case DCB_CONNECTOR_DP :
1259 case DCB_CONNECTOR_USB_C : return DRM_MODE_CONNECTOR_DisplayPort;
1260 case DCB_CONNECTOR_eDP : return DRM_MODE_CONNECTOR_eDP;
1261 case DCB_CONNECTOR_HDMI_0 :
1262 case DCB_CONNECTOR_HDMI_1 :
1263 case DCB_CONNECTOR_HDMI_C : return DRM_MODE_CONNECTOR_HDMIA;
1264 case DCB_CONNECTOR_WFD : return DRM_MODE_CONNECTOR_VIRTUAL;
1265 default:
1266 break;
1267 }
1268
1269 return DRM_MODE_CONNECTOR_Unknown;
1270}
1271
1272struct drm_connector *
1273nouveau_connector_create(struct drm_device *dev,
1274 const struct dcb_output *dcbe)
1275{
1276 const struct drm_connector_funcs *funcs = &nouveau_connector_funcs;
1277 struct nouveau_drm *drm = nouveau_drm(dev);
1278 struct nouveau_display *disp = nouveau_display(dev);
1279 struct nouveau_connector *nv_connector = NULL;
1280 struct drm_connector *connector;
1281 struct drm_connector_list_iter conn_iter;
1282 char aux_name[48] = {0};
1283 int index = dcbe->connector;
1284 int type, ret = 0;
1285 bool dummy;
1286
1287 drm_connector_list_iter_begin(dev, &conn_iter);
1288 nouveau_for_each_non_mst_connector_iter(connector, &conn_iter) {
1289 nv_connector = nouveau_connector(connector);
1290 if (nv_connector->index == index) {
1291 drm_connector_list_iter_end(&conn_iter);
1292 return connector;
1293 }
1294 }
1295 drm_connector_list_iter_end(&conn_iter);
1296
1297 nv_connector = kzalloc(sizeof(*nv_connector), GFP_KERNEL);
1298 if (!nv_connector)
1299 return ERR_PTR(-ENOMEM);
1300
1301 connector = &nv_connector->base;
1302 nv_connector->index = index;
1303
1304
1305 nv_connector->dcb = olddcb_conn(dev, index);
1306 if (nv_connector->dcb) {
1307 u32 entry = ROM16(nv_connector->dcb[0]);
1308 if (olddcb_conntab(dev)[3] >= 4)
1309 entry |= (u32)ROM16(nv_connector->dcb[2]) << 16;
1310
1311 nv_connector->type = nv_connector->dcb[0];
1312 if (drm_conntype_from_dcb(nv_connector->type) ==
1313 DRM_MODE_CONNECTOR_Unknown) {
1314 NV_WARN(drm, "unknown connector type %02x\n",
1315 nv_connector->type);
1316 nv_connector->type = DCB_CONNECTOR_NONE;
1317 }
1318
1319
1320 if (nv_match_device(dev, 0x0421, 0x1458, 0x344c)) {
1321 if (nv_connector->type == DCB_CONNECTOR_HDMI_1)
1322 nv_connector->type = DCB_CONNECTOR_DVI_I;
1323 }
1324
1325
1326 if (nv_match_device(dev, 0x0402, 0x1458, 0x3455)) {
1327 if (nv_connector->type == DCB_CONNECTOR_HDMI_1)
1328 nv_connector->type = DCB_CONNECTOR_DVI_I;
1329 }
1330 } else {
1331 nv_connector->type = DCB_CONNECTOR_NONE;
1332 }
1333
1334
1335
1336
1337 if (nv_connector->type == DCB_CONNECTOR_NONE) {
1338 struct nouveau_drm *drm = nouveau_drm(dev);
1339 struct dcb_table *dcbt = &drm->vbios.dcb;
1340 u32 encoders = 0;
1341 int i;
1342
1343 for (i = 0; i < dcbt->entries; i++) {
1344 if (dcbt->entry[i].connector == nv_connector->index)
1345 encoders |= (1 << dcbt->entry[i].type);
1346 }
1347
1348 if (encoders & (1 << DCB_OUTPUT_DP)) {
1349 if (encoders & (1 << DCB_OUTPUT_TMDS))
1350 nv_connector->type = DCB_CONNECTOR_DP;
1351 else
1352 nv_connector->type = DCB_CONNECTOR_eDP;
1353 } else
1354 if (encoders & (1 << DCB_OUTPUT_TMDS)) {
1355 if (encoders & (1 << DCB_OUTPUT_ANALOG))
1356 nv_connector->type = DCB_CONNECTOR_DVI_I;
1357 else
1358 nv_connector->type = DCB_CONNECTOR_DVI_D;
1359 } else
1360 if (encoders & (1 << DCB_OUTPUT_ANALOG)) {
1361 nv_connector->type = DCB_CONNECTOR_VGA;
1362 } else
1363 if (encoders & (1 << DCB_OUTPUT_LVDS)) {
1364 nv_connector->type = DCB_CONNECTOR_LVDS;
1365 } else
1366 if (encoders & (1 << DCB_OUTPUT_TV)) {
1367 nv_connector->type = DCB_CONNECTOR_TV_0;
1368 }
1369 }
1370
1371 switch ((type = drm_conntype_from_dcb(nv_connector->type))) {
1372 case DRM_MODE_CONNECTOR_LVDS:
1373 ret = nouveau_bios_parse_lvds_table(dev, 0, &dummy, &dummy);
1374 if (ret) {
1375 NV_ERROR(drm, "Error parsing LVDS table, disabling\n");
1376 kfree(nv_connector);
1377 return ERR_PTR(ret);
1378 }
1379
1380 funcs = &nouveau_connector_funcs_lvds;
1381 break;
1382 case DRM_MODE_CONNECTOR_DisplayPort:
1383 case DRM_MODE_CONNECTOR_eDP:
1384 nv_connector->aux.dev = connector->kdev;
1385 nv_connector->aux.transfer = nouveau_connector_aux_xfer;
1386 snprintf(aux_name, sizeof(aux_name), "sor-%04x-%04x",
1387 dcbe->hasht, dcbe->hashm);
1388 nv_connector->aux.name = kstrdup(aux_name, GFP_KERNEL);
1389 ret = drm_dp_aux_register(&nv_connector->aux);
1390 if (ret) {
1391 NV_ERROR(drm, "failed to register aux channel\n");
1392 kfree(nv_connector);
1393 return ERR_PTR(ret);
1394 }
1395 funcs = &nouveau_connector_funcs;
1396 break;
1397 default:
1398 funcs = &nouveau_connector_funcs;
1399 break;
1400 }
1401
1402
1403 if ((disp->disp.object.oclass >= G82_DISP)
1404 && ((type == DRM_MODE_CONNECTOR_DisplayPort)
1405 || (type == DRM_MODE_CONNECTOR_eDP)
1406 || (type == DRM_MODE_CONNECTOR_HDMIA)))
1407 connector->stereo_allowed = true;
1408
1409
1410 connector->interlace_allowed = false;
1411 connector->doublescan_allowed = false;
1412
1413 drm_connector_init(dev, connector, funcs, type);
1414 drm_connector_helper_add(connector, &nouveau_connector_helper_funcs);
1415
1416 connector->funcs->reset(connector);
1417 nouveau_conn_attach_properties(connector);
1418
1419
1420 switch (nv_connector->type) {
1421 case DCB_CONNECTOR_LVDS:
1422 case DCB_CONNECTOR_LVDS_SPWG:
1423 case DCB_CONNECTOR_eDP:
1424
1425 if (disp->disp.object.oclass < NV50_DISP) {
1426 nv_connector->scaling_mode = DRM_MODE_SCALE_FULLSCREEN;
1427 break;
1428 }
1429 nv_connector->scaling_mode = DRM_MODE_SCALE_NONE;
1430 break;
1431 default:
1432 nv_connector->scaling_mode = DRM_MODE_SCALE_NONE;
1433 break;
1434 }
1435
1436
1437 switch (nv_connector->type) {
1438 case DCB_CONNECTOR_TV_0:
1439 case DCB_CONNECTOR_TV_1:
1440 case DCB_CONNECTOR_TV_3:
1441 case DCB_CONNECTOR_VGA:
1442 break;
1443 default:
1444 nv_connector->dithering_mode = DITHERING_MODE_AUTO;
1445 break;
1446 }
1447
1448 switch (type) {
1449 case DRM_MODE_CONNECTOR_DisplayPort:
1450 case DRM_MODE_CONNECTOR_eDP:
1451 drm_dp_cec_register_connector(&nv_connector->aux, connector);
1452 break;
1453 }
1454
1455 ret = nvif_notify_init(&disp->disp.object, nouveau_connector_hotplug,
1456 true, NV04_DISP_NTFY_CONN,
1457 &(struct nvif_notify_conn_req_v0) {
1458 .mask = NVIF_NOTIFY_CONN_V0_ANY,
1459 .conn = index,
1460 },
1461 sizeof(struct nvif_notify_conn_req_v0),
1462 sizeof(struct nvif_notify_conn_rep_v0),
1463 &nv_connector->hpd);
1464 if (ret)
1465 connector->polled = DRM_CONNECTOR_POLL_CONNECT;
1466 else
1467 connector->polled = DRM_CONNECTOR_POLL_HPD;
1468
1469 drm_connector_register(connector);
1470 return connector;
1471}
1472
