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
28
29
30
31
32#include <linux/export.h>
33#include <linux/moduleparam.h>
34
35#include <drm/drmP.h>
36#include <drm/drm_crtc.h>
37#include <drm/drm_fourcc.h>
38#include <drm/drm_crtc_helper.h>
39#include <drm/drm_fb_helper.h>
40#include <drm/drm_edid.h>
41
42
43
44
45
46
47
48
49
50
51
52
53void drm_helper_move_panel_connectors_to_head(struct drm_device *dev)
54{
55 struct drm_connector *connector, *tmp;
56 struct list_head panel_list;
57
58 INIT_LIST_HEAD(&panel_list);
59
60 list_for_each_entry_safe(connector, tmp,
61 &dev->mode_config.connector_list, head) {
62 if (connector->connector_type == DRM_MODE_CONNECTOR_LVDS ||
63 connector->connector_type == DRM_MODE_CONNECTOR_eDP)
64 list_move_tail(&connector->head, &panel_list);
65 }
66
67 list_splice(&panel_list, &dev->mode_config.connector_list);
68}
69EXPORT_SYMBOL(drm_helper_move_panel_connectors_to_head);
70
71static bool drm_kms_helper_poll = true;
72module_param_named(poll, drm_kms_helper_poll, bool, 0600);
73
74static void drm_mode_validate_flag(struct drm_connector *connector,
75 int flags)
76{
77 struct drm_display_mode *mode;
78
79 if (flags == (DRM_MODE_FLAG_DBLSCAN | DRM_MODE_FLAG_INTERLACE))
80 return;
81
82 list_for_each_entry(mode, &connector->modes, head) {
83 if ((mode->flags & DRM_MODE_FLAG_INTERLACE) &&
84 !(flags & DRM_MODE_FLAG_INTERLACE))
85 mode->status = MODE_NO_INTERLACE;
86 if ((mode->flags & DRM_MODE_FLAG_DBLSCAN) &&
87 !(flags & DRM_MODE_FLAG_DBLSCAN))
88 mode->status = MODE_NO_DBLESCAN;
89 }
90
91 return;
92}
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115int drm_helper_probe_single_connector_modes(struct drm_connector *connector,
116 uint32_t maxX, uint32_t maxY)
117{
118 struct drm_device *dev = connector->dev;
119 struct drm_display_mode *mode;
120 struct drm_connector_helper_funcs *connector_funcs =
121 connector->helper_private;
122 int count = 0;
123 int mode_flags = 0;
124
125 DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n", connector->base.id,
126 drm_get_connector_name(connector));
127
128 list_for_each_entry(mode, &connector->modes, head)
129 mode->status = MODE_UNVERIFIED;
130
131 if (connector->force) {
132 if (connector->force == DRM_FORCE_ON)
133 connector->status = connector_status_connected;
134 else
135 connector->status = connector_status_disconnected;
136 if (connector->funcs->force)
137 connector->funcs->force(connector);
138 } else {
139 connector->status = connector->funcs->detect(connector, true);
140 }
141
142
143 if (drm_kms_helper_poll != dev->mode_config.poll_running)
144 drm_kms_helper_poll_enable(dev);
145
146 dev->mode_config.poll_running = drm_kms_helper_poll;
147
148 if (connector->status == connector_status_disconnected) {
149 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] disconnected\n",
150 connector->base.id, drm_get_connector_name(connector));
151 drm_mode_connector_update_edid_property(connector, NULL);
152 goto prune;
153 }
154
155#ifdef CONFIG_DRM_LOAD_EDID_FIRMWARE
156 count = drm_load_edid_firmware(connector);
157 if (count == 0)
158#endif
159 count = (*connector_funcs->get_modes)(connector);
160
161 if (count == 0 && connector->status == connector_status_connected)
162 count = drm_add_modes_noedid(connector, 1024, 768);
163 if (count == 0)
164 goto prune;
165
166 drm_mode_connector_list_update(connector);
167
168 if (maxX && maxY)
169 drm_mode_validate_size(dev, &connector->modes, maxX,
170 maxY, 0);
171
172 if (connector->interlace_allowed)
173 mode_flags |= DRM_MODE_FLAG_INTERLACE;
174 if (connector->doublescan_allowed)
175 mode_flags |= DRM_MODE_FLAG_DBLSCAN;
176 drm_mode_validate_flag(connector, mode_flags);
177
178 list_for_each_entry(mode, &connector->modes, head) {
179 if (mode->status == MODE_OK)
180 mode->status = connector_funcs->mode_valid(connector,
181 mode);
182 }
183
184prune:
185 drm_mode_prune_invalid(dev, &connector->modes, true);
186
187 if (list_empty(&connector->modes))
188 return 0;
189
190 drm_mode_sort(&connector->modes);
191
192 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] probed modes :\n", connector->base.id,
193 drm_get_connector_name(connector));
194 list_for_each_entry(mode, &connector->modes, head) {
195 mode->vrefresh = drm_mode_vrefresh(mode);
196
197 drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V);
198 drm_mode_debug_printmodeline(mode);
199 }
200
201 return count;
202}
203EXPORT_SYMBOL(drm_helper_probe_single_connector_modes);
204
205
206
207
208
209
210
211
212
213
214
215
216
217bool drm_helper_encoder_in_use(struct drm_encoder *encoder)
218{
219 struct drm_connector *connector;
220 struct drm_device *dev = encoder->dev;
221 list_for_each_entry(connector, &dev->mode_config.connector_list, head)
222 if (connector->encoder == encoder)
223 return true;
224 return false;
225}
226EXPORT_SYMBOL(drm_helper_encoder_in_use);
227
228
229
230
231
232
233
234
235
236
237
238
239
240bool drm_helper_crtc_in_use(struct drm_crtc *crtc)
241{
242 struct drm_encoder *encoder;
243 struct drm_device *dev = crtc->dev;
244
245 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head)
246 if (encoder->crtc == crtc && drm_helper_encoder_in_use(encoder))
247 return true;
248 return false;
249}
250EXPORT_SYMBOL(drm_helper_crtc_in_use);
251
252static void
253drm_encoder_disable(struct drm_encoder *encoder)
254{
255 struct drm_encoder_helper_funcs *encoder_funcs = encoder->helper_private;
256
257 if (encoder_funcs->disable)
258 (*encoder_funcs->disable)(encoder);
259 else
260 (*encoder_funcs->dpms)(encoder, DRM_MODE_DPMS_OFF);
261}
262
263
264
265
266
267
268
269
270
271
272
273void drm_helper_disable_unused_functions(struct drm_device *dev)
274{
275 struct drm_encoder *encoder;
276 struct drm_connector *connector;
277 struct drm_crtc *crtc;
278
279 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
280 if (!connector->encoder)
281 continue;
282 if (connector->status == connector_status_disconnected)
283 connector->encoder = NULL;
284 }
285
286 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
287 if (!drm_helper_encoder_in_use(encoder)) {
288 drm_encoder_disable(encoder);
289
290 encoder->crtc = NULL;
291 }
292 }
293
294 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
295 struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
296 crtc->enabled = drm_helper_crtc_in_use(crtc);
297 if (!crtc->enabled) {
298 if (crtc_funcs->disable)
299 (*crtc_funcs->disable)(crtc);
300 else
301 (*crtc_funcs->dpms)(crtc, DRM_MODE_DPMS_OFF);
302 crtc->fb = NULL;
303 }
304 }
305}
306EXPORT_SYMBOL(drm_helper_disable_unused_functions);
307
308
309
310
311
312
313
314
315static bool drm_encoder_crtc_ok(struct drm_encoder *encoder,
316 struct drm_crtc *crtc)
317{
318 struct drm_device *dev;
319 struct drm_crtc *tmp;
320 int crtc_mask = 1;
321
322 WARN(!crtc, "checking null crtc?\n");
323
324 dev = crtc->dev;
325
326 list_for_each_entry(tmp, &dev->mode_config.crtc_list, head) {
327 if (tmp == crtc)
328 break;
329 crtc_mask <<= 1;
330 }
331
332 if (encoder->possible_crtcs & crtc_mask)
333 return true;
334 return false;
335}
336
337
338
339
340
341
342static void
343drm_crtc_prepare_encoders(struct drm_device *dev)
344{
345 struct drm_encoder_helper_funcs *encoder_funcs;
346 struct drm_encoder *encoder;
347
348 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
349 encoder_funcs = encoder->helper_private;
350
351 if (encoder->crtc == NULL)
352 drm_encoder_disable(encoder);
353
354 if (encoder_funcs->get_crtc &&
355 encoder->crtc != (*encoder_funcs->get_crtc)(encoder))
356 drm_encoder_disable(encoder);
357 }
358}
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383bool drm_crtc_helper_set_mode(struct drm_crtc *crtc,
384 struct drm_display_mode *mode,
385 int x, int y,
386 struct drm_framebuffer *old_fb)
387{
388 struct drm_device *dev = crtc->dev;
389 struct drm_display_mode *adjusted_mode, saved_mode, saved_hwmode;
390 struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
391 struct drm_encoder_helper_funcs *encoder_funcs;
392 int saved_x, saved_y;
393 struct drm_encoder *encoder;
394 bool ret = true;
395
396 crtc->enabled = drm_helper_crtc_in_use(crtc);
397 if (!crtc->enabled)
398 return true;
399
400 adjusted_mode = drm_mode_duplicate(dev, mode);
401 if (!adjusted_mode)
402 return false;
403
404 saved_hwmode = crtc->hwmode;
405 saved_mode = crtc->mode;
406 saved_x = crtc->x;
407 saved_y = crtc->y;
408
409
410
411
412 crtc->mode = *mode;
413 crtc->x = x;
414 crtc->y = y;
415
416
417
418
419
420 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
421
422 if (encoder->crtc != crtc)
423 continue;
424 encoder_funcs = encoder->helper_private;
425 if (!(ret = encoder_funcs->mode_fixup(encoder, mode,
426 adjusted_mode))) {
427 DRM_DEBUG_KMS("Encoder fixup failed\n");
428 goto done;
429 }
430 }
431
432 if (!(ret = crtc_funcs->mode_fixup(crtc, mode, adjusted_mode))) {
433 DRM_DEBUG_KMS("CRTC fixup failed\n");
434 goto done;
435 }
436 DRM_DEBUG_KMS("[CRTC:%d]\n", crtc->base.id);
437
438
439 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
440
441 if (encoder->crtc != crtc)
442 continue;
443 encoder_funcs = encoder->helper_private;
444
445 encoder_funcs->prepare(encoder);
446 }
447
448 drm_crtc_prepare_encoders(dev);
449
450 crtc_funcs->prepare(crtc);
451
452
453
454
455 ret = !crtc_funcs->mode_set(crtc, mode, adjusted_mode, x, y, old_fb);
456 if (!ret)
457 goto done;
458
459 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
460
461 if (encoder->crtc != crtc)
462 continue;
463
464 DRM_DEBUG_KMS("[ENCODER:%d:%s] set [MODE:%d:%s]\n",
465 encoder->base.id, drm_get_encoder_name(encoder),
466 mode->base.id, mode->name);
467 encoder_funcs = encoder->helper_private;
468 encoder_funcs->mode_set(encoder, mode, adjusted_mode);
469 }
470
471
472 crtc_funcs->commit(crtc);
473
474 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
475
476 if (encoder->crtc != crtc)
477 continue;
478
479 encoder_funcs = encoder->helper_private;
480 encoder_funcs->commit(encoder);
481
482 }
483
484
485 crtc->hwmode = *adjusted_mode;
486
487
488
489
490
491 drm_calc_timestamping_constants(crtc);
492
493
494done:
495 drm_mode_destroy(dev, adjusted_mode);
496 if (!ret) {
497 crtc->hwmode = saved_hwmode;
498 crtc->mode = saved_mode;
499 crtc->x = saved_x;
500 crtc->y = saved_y;
501 }
502
503 return ret;
504}
505EXPORT_SYMBOL(drm_crtc_helper_set_mode);
506
507
508static int
509drm_crtc_helper_disable(struct drm_crtc *crtc)
510{
511 struct drm_device *dev = crtc->dev;
512 struct drm_connector *connector;
513 struct drm_encoder *encoder;
514
515
516 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
517 if (encoder->crtc != crtc)
518 continue;
519
520 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
521 if (connector->encoder != encoder)
522 continue;
523
524 connector->encoder = NULL;
525 }
526 }
527
528 drm_helper_disable_unused_functions(dev);
529 return 0;
530}
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548int drm_crtc_helper_set_config(struct drm_mode_set *set)
549{
550 struct drm_device *dev;
551 struct drm_crtc *save_crtcs, *new_crtc, *crtc;
552 struct drm_encoder *save_encoders, *new_encoder, *encoder;
553 struct drm_framebuffer *old_fb = NULL;
554 bool mode_changed = false;
555 bool fb_changed = false;
556 struct drm_connector *save_connectors, *connector;
557 int count = 0, ro, fail = 0;
558 struct drm_crtc_helper_funcs *crtc_funcs;
559 struct drm_mode_set save_set;
560 int ret;
561 int i;
562
563 DRM_DEBUG_KMS("\n");
564
565 if (!set)
566 return -EINVAL;
567
568 if (!set->crtc)
569 return -EINVAL;
570
571 if (!set->crtc->helper_private)
572 return -EINVAL;
573
574 crtc_funcs = set->crtc->helper_private;
575
576 if (!set->mode)
577 set->fb = NULL;
578
579 if (set->fb) {
580 DRM_DEBUG_KMS("[CRTC:%d] [FB:%d] #connectors=%d (x y) (%i %i)\n",
581 set->crtc->base.id, set->fb->base.id,
582 (int)set->num_connectors, set->x, set->y);
583 } else {
584 DRM_DEBUG_KMS("[CRTC:%d] [NOFB]\n", set->crtc->base.id);
585 return drm_crtc_helper_disable(set->crtc);
586 }
587
588 dev = set->crtc->dev;
589
590
591
592 save_crtcs = kzalloc(dev->mode_config.num_crtc *
593 sizeof(struct drm_crtc), GFP_KERNEL);
594 if (!save_crtcs)
595 return -ENOMEM;
596
597 save_encoders = kzalloc(dev->mode_config.num_encoder *
598 sizeof(struct drm_encoder), GFP_KERNEL);
599 if (!save_encoders) {
600 kfree(save_crtcs);
601 return -ENOMEM;
602 }
603
604 save_connectors = kzalloc(dev->mode_config.num_connector *
605 sizeof(struct drm_connector), GFP_KERNEL);
606 if (!save_connectors) {
607 kfree(save_crtcs);
608 kfree(save_encoders);
609 return -ENOMEM;
610 }
611
612
613
614
615
616 count = 0;
617 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
618 save_crtcs[count++] = *crtc;
619 }
620
621 count = 0;
622 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
623 save_encoders[count++] = *encoder;
624 }
625
626 count = 0;
627 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
628 save_connectors[count++] = *connector;
629 }
630
631 save_set.crtc = set->crtc;
632 save_set.mode = &set->crtc->mode;
633 save_set.x = set->crtc->x;
634 save_set.y = set->crtc->y;
635 save_set.fb = set->crtc->fb;
636
637
638
639 if (set->crtc->fb != set->fb) {
640
641 if (set->crtc->fb == NULL) {
642 DRM_DEBUG_KMS("crtc has no fb, full mode set\n");
643 mode_changed = true;
644 } else if (set->fb == NULL) {
645 mode_changed = true;
646 } else if (set->fb->depth != set->crtc->fb->depth) {
647 mode_changed = true;
648 } else if (set->fb->bits_per_pixel !=
649 set->crtc->fb->bits_per_pixel) {
650 mode_changed = true;
651 } else
652 fb_changed = true;
653 }
654
655 if (set->x != set->crtc->x || set->y != set->crtc->y)
656 fb_changed = true;
657
658 if (set->mode && !drm_mode_equal(set->mode, &set->crtc->mode)) {
659 DRM_DEBUG_KMS("modes are different, full mode set\n");
660 drm_mode_debug_printmodeline(&set->crtc->mode);
661 drm_mode_debug_printmodeline(set->mode);
662 mode_changed = true;
663 }
664
665
666 count = 0;
667 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
668 struct drm_connector_helper_funcs *connector_funcs =
669 connector->helper_private;
670 new_encoder = connector->encoder;
671 for (ro = 0; ro < set->num_connectors; ro++) {
672 if (set->connectors[ro] == connector) {
673 new_encoder = connector_funcs->best_encoder(connector);
674
675
676 if (new_encoder == NULL)
677
678 fail = 1;
679 break;
680 }
681 }
682
683 if (new_encoder != connector->encoder) {
684 DRM_DEBUG_KMS("encoder changed, full mode switch\n");
685 mode_changed = true;
686
687
688
689 if (connector->encoder)
690 connector->encoder->crtc = NULL;
691 connector->encoder = new_encoder;
692 }
693 }
694
695 if (fail) {
696 ret = -EINVAL;
697 goto fail;
698 }
699
700 count = 0;
701 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
702 if (!connector->encoder)
703 continue;
704
705 if (connector->encoder->crtc == set->crtc)
706 new_crtc = NULL;
707 else
708 new_crtc = connector->encoder->crtc;
709
710 for (ro = 0; ro < set->num_connectors; ro++) {
711 if (set->connectors[ro] == connector)
712 new_crtc = set->crtc;
713 }
714
715
716 if (new_crtc &&
717 !drm_encoder_crtc_ok(connector->encoder, new_crtc)) {
718 ret = -EINVAL;
719 goto fail;
720 }
721 if (new_crtc != connector->encoder->crtc) {
722 DRM_DEBUG_KMS("crtc changed, full mode switch\n");
723 mode_changed = true;
724 connector->encoder->crtc = new_crtc;
725 }
726 if (new_crtc) {
727 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] to [CRTC:%d]\n",
728 connector->base.id, drm_get_connector_name(connector),
729 new_crtc->base.id);
730 } else {
731 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] to [NOCRTC]\n",
732 connector->base.id, drm_get_connector_name(connector));
733 }
734 }
735
736
737 if (fb_changed && !crtc_funcs->mode_set_base)
738 mode_changed = true;
739
740 if (mode_changed) {
741 set->crtc->enabled = drm_helper_crtc_in_use(set->crtc);
742 if (set->crtc->enabled) {
743 DRM_DEBUG_KMS("attempting to set mode from"
744 " userspace\n");
745 drm_mode_debug_printmodeline(set->mode);
746 old_fb = set->crtc->fb;
747 set->crtc->fb = set->fb;
748 if (!drm_crtc_helper_set_mode(set->crtc, set->mode,
749 set->x, set->y,
750 old_fb)) {
751 DRM_ERROR("failed to set mode on [CRTC:%d]\n",
752 set->crtc->base.id);
753 set->crtc->fb = old_fb;
754 ret = -EINVAL;
755 goto fail;
756 }
757 DRM_DEBUG_KMS("Setting connector DPMS state to on\n");
758 for (i = 0; i < set->num_connectors; i++) {
759 DRM_DEBUG_KMS("\t[CONNECTOR:%d:%s] set DPMS on\n", set->connectors[i]->base.id,
760 drm_get_connector_name(set->connectors[i]));
761 set->connectors[i]->funcs->dpms(set->connectors[i], DRM_MODE_DPMS_ON);
762 }
763 }
764 drm_helper_disable_unused_functions(dev);
765 } else if (fb_changed) {
766 set->crtc->x = set->x;
767 set->crtc->y = set->y;
768
769 old_fb = set->crtc->fb;
770 if (set->crtc->fb != set->fb)
771 set->crtc->fb = set->fb;
772 ret = crtc_funcs->mode_set_base(set->crtc,
773 set->x, set->y, old_fb);
774 if (ret != 0) {
775 set->crtc->fb = old_fb;
776 goto fail;
777 }
778 }
779
780 kfree(save_connectors);
781 kfree(save_encoders);
782 kfree(save_crtcs);
783 return 0;
784
785fail:
786
787 count = 0;
788 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
789 *crtc = save_crtcs[count++];
790 }
791
792 count = 0;
793 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
794 *encoder = save_encoders[count++];
795 }
796
797 count = 0;
798 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
799 *connector = save_connectors[count++];
800 }
801
802
803 if (mode_changed &&
804 !drm_crtc_helper_set_mode(save_set.crtc, save_set.mode, save_set.x,
805 save_set.y, save_set.fb))
806 DRM_ERROR("failed to restore config after modeset failure\n");
807
808 kfree(save_connectors);
809 kfree(save_encoders);
810 kfree(save_crtcs);
811 return ret;
812}
813EXPORT_SYMBOL(drm_crtc_helper_set_config);
814
815static int drm_helper_choose_encoder_dpms(struct drm_encoder *encoder)
816{
817 int dpms = DRM_MODE_DPMS_OFF;
818 struct drm_connector *connector;
819 struct drm_device *dev = encoder->dev;
820
821 list_for_each_entry(connector, &dev->mode_config.connector_list, head)
822 if (connector->encoder == encoder)
823 if (connector->dpms < dpms)
824 dpms = connector->dpms;
825 return dpms;
826}
827
828static int drm_helper_choose_crtc_dpms(struct drm_crtc *crtc)
829{
830 int dpms = DRM_MODE_DPMS_OFF;
831 struct drm_connector *connector;
832 struct drm_device *dev = crtc->dev;
833
834 list_for_each_entry(connector, &dev->mode_config.connector_list, head)
835 if (connector->encoder && connector->encoder->crtc == crtc)
836 if (connector->dpms < dpms)
837 dpms = connector->dpms;
838 return dpms;
839}
840
841
842
843
844
845
846
847
848
849
850
851void drm_helper_connector_dpms(struct drm_connector *connector, int mode)
852{
853 struct drm_encoder *encoder = connector->encoder;
854 struct drm_crtc *crtc = encoder ? encoder->crtc : NULL;
855 int old_dpms;
856
857 if (mode == connector->dpms)
858 return;
859
860 old_dpms = connector->dpms;
861 connector->dpms = mode;
862
863
864 if (mode < old_dpms) {
865 if (crtc) {
866 struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
867 if (crtc_funcs->dpms)
868 (*crtc_funcs->dpms) (crtc,
869 drm_helper_choose_crtc_dpms(crtc));
870 }
871 if (encoder) {
872 struct drm_encoder_helper_funcs *encoder_funcs = encoder->helper_private;
873 if (encoder_funcs->dpms)
874 (*encoder_funcs->dpms) (encoder,
875 drm_helper_choose_encoder_dpms(encoder));
876 }
877 }
878
879
880 if (mode > old_dpms) {
881 if (encoder) {
882 struct drm_encoder_helper_funcs *encoder_funcs = encoder->helper_private;
883 if (encoder_funcs->dpms)
884 (*encoder_funcs->dpms) (encoder,
885 drm_helper_choose_encoder_dpms(encoder));
886 }
887 if (crtc) {
888 struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
889 if (crtc_funcs->dpms)
890 (*crtc_funcs->dpms) (crtc,
891 drm_helper_choose_crtc_dpms(crtc));
892 }
893 }
894
895 return;
896}
897EXPORT_SYMBOL(drm_helper_connector_dpms);
898
899int drm_helper_mode_fill_fb_struct(struct drm_framebuffer *fb,
900 struct drm_mode_fb_cmd2 *mode_cmd)
901{
902 int i;
903
904 fb->width = mode_cmd->width;
905 fb->height = mode_cmd->height;
906 for (i = 0; i < 4; i++) {
907 fb->pitches[i] = mode_cmd->pitches[i];
908 fb->offsets[i] = mode_cmd->offsets[i];
909 }
910 drm_fb_get_bpp_depth(mode_cmd->pixel_format, &fb->depth,
911 &fb->bits_per_pixel);
912 fb->pixel_format = mode_cmd->pixel_format;
913
914 return 0;
915}
916EXPORT_SYMBOL(drm_helper_mode_fill_fb_struct);
917
918int drm_helper_resume_force_mode(struct drm_device *dev)
919{
920 struct drm_crtc *crtc;
921 struct drm_encoder *encoder;
922 struct drm_encoder_helper_funcs *encoder_funcs;
923 struct drm_crtc_helper_funcs *crtc_funcs;
924 int ret;
925
926 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
927
928 if (!crtc->enabled)
929 continue;
930
931 ret = drm_crtc_helper_set_mode(crtc, &crtc->mode,
932 crtc->x, crtc->y, crtc->fb);
933
934 if (ret == false)
935 DRM_ERROR("failed to set mode on crtc %p\n", crtc);
936
937
938 if (drm_helper_choose_crtc_dpms(crtc)) {
939 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
940
941 if(encoder->crtc != crtc)
942 continue;
943
944 encoder_funcs = encoder->helper_private;
945 if (encoder_funcs->dpms)
946 (*encoder_funcs->dpms) (encoder,
947 drm_helper_choose_encoder_dpms(encoder));
948 }
949
950 crtc_funcs = crtc->helper_private;
951 if (crtc_funcs->dpms)
952 (*crtc_funcs->dpms) (crtc,
953 drm_helper_choose_crtc_dpms(crtc));
954 }
955 }
956
957 drm_helper_disable_unused_functions(dev);
958 return 0;
959}
960EXPORT_SYMBOL(drm_helper_resume_force_mode);
961
962void drm_kms_helper_hotplug_event(struct drm_device *dev)
963{
964
965 drm_sysfs_hotplug_event(dev);
966 if (dev->mode_config.funcs->output_poll_changed)
967 dev->mode_config.funcs->output_poll_changed(dev);
968}
969EXPORT_SYMBOL(drm_kms_helper_hotplug_event);
970
971#define DRM_OUTPUT_POLL_PERIOD (10*HZ)
972static void output_poll_execute(struct work_struct *work)
973{
974 struct delayed_work *delayed_work = to_delayed_work(work);
975 struct drm_device *dev = container_of(delayed_work, struct drm_device, mode_config.output_poll_work);
976 struct drm_connector *connector;
977 enum drm_connector_status old_status;
978 bool repoll = false, changed = false;
979
980 if (!drm_kms_helper_poll)
981 return;
982
983 mutex_lock(&dev->mode_config.mutex);
984 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
985
986
987 if (connector->force)
988 continue;
989
990
991
992 if (!connector->polled || connector->polled == DRM_CONNECTOR_POLL_HPD)
993 continue;
994
995 repoll = true;
996
997 old_status = connector->status;
998
999
1000 if (old_status == connector_status_connected &&
1001 !(connector->polled & DRM_CONNECTOR_POLL_DISCONNECT))
1002 continue;
1003
1004 connector->status = connector->funcs->detect(connector, false);
1005 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] status updated from %d to %d\n",
1006 connector->base.id,
1007 drm_get_connector_name(connector),
1008 old_status, connector->status);
1009 if (old_status != connector->status)
1010 changed = true;
1011 }
1012
1013 mutex_unlock(&dev->mode_config.mutex);
1014
1015 if (changed)
1016 drm_kms_helper_hotplug_event(dev);
1017
1018 if (repoll)
1019 schedule_delayed_work(delayed_work, DRM_OUTPUT_POLL_PERIOD);
1020}
1021
1022void drm_kms_helper_poll_disable(struct drm_device *dev)
1023{
1024 if (!dev->mode_config.poll_enabled)
1025 return;
1026 cancel_delayed_work_sync(&dev->mode_config.output_poll_work);
1027}
1028EXPORT_SYMBOL(drm_kms_helper_poll_disable);
1029
1030void drm_kms_helper_poll_enable(struct drm_device *dev)
1031{
1032 bool poll = false;
1033 struct drm_connector *connector;
1034
1035 if (!dev->mode_config.poll_enabled || !drm_kms_helper_poll)
1036 return;
1037
1038 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
1039 if (connector->polled & (DRM_CONNECTOR_POLL_CONNECT |
1040 DRM_CONNECTOR_POLL_DISCONNECT))
1041 poll = true;
1042 }
1043
1044 if (poll)
1045 schedule_delayed_work(&dev->mode_config.output_poll_work, DRM_OUTPUT_POLL_PERIOD);
1046}
1047EXPORT_SYMBOL(drm_kms_helper_poll_enable);
1048
1049void drm_kms_helper_poll_init(struct drm_device *dev)
1050{
1051 INIT_DELAYED_WORK(&dev->mode_config.output_poll_work, output_poll_execute);
1052 dev->mode_config.poll_enabled = true;
1053
1054 drm_kms_helper_poll_enable(dev);
1055}
1056EXPORT_SYMBOL(drm_kms_helper_poll_init);
1057
1058void drm_kms_helper_poll_fini(struct drm_device *dev)
1059{
1060 drm_kms_helper_poll_disable(dev);
1061}
1062EXPORT_SYMBOL(drm_kms_helper_poll_fini);
1063
1064void drm_helper_hpd_irq_event(struct drm_device *dev)
1065{
1066 struct drm_connector *connector;
1067 enum drm_connector_status old_status;
1068 bool changed = false;
1069
1070 if (!dev->mode_config.poll_enabled)
1071 return;
1072
1073 mutex_lock(&dev->mode_config.mutex);
1074 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
1075
1076
1077 if (!(connector->polled & DRM_CONNECTOR_POLL_HPD))
1078 continue;
1079
1080 old_status = connector->status;
1081
1082 connector->status = connector->funcs->detect(connector, false);
1083 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] status updated from %d to %d\n",
1084 connector->base.id,
1085 drm_get_connector_name(connector),
1086 old_status, connector->status);
1087 if (old_status != connector->status)
1088 changed = true;
1089 }
1090
1091 mutex_unlock(&dev->mode_config.mutex);
1092
1093 if (changed)
1094 drm_kms_helper_hotplug_event(dev);
1095}
1096EXPORT_SYMBOL(drm_helper_hpd_irq_event);
1097