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#include <linux/dma-fence.h>
29#include <linux/ktime.h>
30
31#include <drm/drm_atomic.h>
32#include <drm/drm_atomic_helper.h>
33#include <drm/drm_atomic_uapi.h>
34#include <drm/drm_bridge.h>
35#include <drm/drm_damage_helper.h>
36#include <drm/drm_device.h>
37#include <drm/drm_drv.h>
38#include <drm/drm_plane_helper.h>
39#include <drm/drm_print.h>
40#include <drm/drm_self_refresh_helper.h>
41#include <drm/drm_vblank.h>
42#include <drm/drm_writeback.h>
43
44#include "drm_crtc_helper_internal.h"
45#include "drm_crtc_internal.h"
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74static void
75drm_atomic_helper_plane_changed(struct drm_atomic_state *state,
76 struct drm_plane_state *old_plane_state,
77 struct drm_plane_state *plane_state,
78 struct drm_plane *plane)
79{
80 struct drm_crtc_state *crtc_state;
81
82 if (old_plane_state->crtc) {
83 crtc_state = drm_atomic_get_new_crtc_state(state,
84 old_plane_state->crtc);
85
86 if (WARN_ON(!crtc_state))
87 return;
88
89 crtc_state->planes_changed = true;
90 }
91
92 if (plane_state->crtc) {
93 crtc_state = drm_atomic_get_new_crtc_state(state, plane_state->crtc);
94
95 if (WARN_ON(!crtc_state))
96 return;
97
98 crtc_state->planes_changed = true;
99 }
100}
101
102static int handle_conflicting_encoders(struct drm_atomic_state *state,
103 bool disable_conflicting_encoders)
104{
105 struct drm_connector_state *new_conn_state;
106 struct drm_connector *connector;
107 struct drm_connector_list_iter conn_iter;
108 struct drm_encoder *encoder;
109 unsigned encoder_mask = 0;
110 int i, ret = 0;
111
112
113
114
115
116
117 for_each_new_connector_in_state(state, connector, new_conn_state, i) {
118 const struct drm_connector_helper_funcs *funcs = connector->helper_private;
119 struct drm_encoder *new_encoder;
120
121 if (!new_conn_state->crtc)
122 continue;
123
124 if (funcs->atomic_best_encoder)
125 new_encoder = funcs->atomic_best_encoder(connector,
126 state);
127 else if (funcs->best_encoder)
128 new_encoder = funcs->best_encoder(connector);
129 else
130 new_encoder = drm_connector_get_single_encoder(connector);
131
132 if (new_encoder) {
133 if (encoder_mask & drm_encoder_mask(new_encoder)) {
134 DRM_DEBUG_ATOMIC("[ENCODER:%d:%s] on [CONNECTOR:%d:%s] already assigned\n",
135 new_encoder->base.id, new_encoder->name,
136 connector->base.id, connector->name);
137
138 return -EINVAL;
139 }
140
141 encoder_mask |= drm_encoder_mask(new_encoder);
142 }
143 }
144
145 if (!encoder_mask)
146 return 0;
147
148
149
150
151
152
153
154
155
156
157
158
159 drm_connector_list_iter_begin(state->dev, &conn_iter);
160 drm_for_each_connector_iter(connector, &conn_iter) {
161 struct drm_crtc_state *crtc_state;
162
163 if (drm_atomic_get_new_connector_state(state, connector))
164 continue;
165
166 encoder = connector->state->best_encoder;
167 if (!encoder || !(encoder_mask & drm_encoder_mask(encoder)))
168 continue;
169
170 if (!disable_conflicting_encoders) {
171 DRM_DEBUG_ATOMIC("[ENCODER:%d:%s] in use on [CRTC:%d:%s] by [CONNECTOR:%d:%s]\n",
172 encoder->base.id, encoder->name,
173 connector->state->crtc->base.id,
174 connector->state->crtc->name,
175 connector->base.id, connector->name);
176 ret = -EINVAL;
177 goto out;
178 }
179
180 new_conn_state = drm_atomic_get_connector_state(state, connector);
181 if (IS_ERR(new_conn_state)) {
182 ret = PTR_ERR(new_conn_state);
183 goto out;
184 }
185
186 DRM_DEBUG_ATOMIC("[ENCODER:%d:%s] in use on [CRTC:%d:%s], disabling [CONNECTOR:%d:%s]\n",
187 encoder->base.id, encoder->name,
188 new_conn_state->crtc->base.id, new_conn_state->crtc->name,
189 connector->base.id, connector->name);
190
191 crtc_state = drm_atomic_get_new_crtc_state(state, new_conn_state->crtc);
192
193 ret = drm_atomic_set_crtc_for_connector(new_conn_state, NULL);
194 if (ret)
195 goto out;
196
197 if (!crtc_state->connector_mask) {
198 ret = drm_atomic_set_mode_prop_for_crtc(crtc_state,
199 NULL);
200 if (ret < 0)
201 goto out;
202
203 crtc_state->active = false;
204 }
205 }
206out:
207 drm_connector_list_iter_end(&conn_iter);
208
209 return ret;
210}
211
212static void
213set_best_encoder(struct drm_atomic_state *state,
214 struct drm_connector_state *conn_state,
215 struct drm_encoder *encoder)
216{
217 struct drm_crtc_state *crtc_state;
218 struct drm_crtc *crtc;
219
220 if (conn_state->best_encoder) {
221
222 crtc = conn_state->connector->state->crtc;
223
224
225
226
227
228
229
230 WARN_ON(!crtc && encoder != conn_state->best_encoder);
231 if (crtc) {
232 crtc_state = drm_atomic_get_new_crtc_state(state, crtc);
233
234 crtc_state->encoder_mask &=
235 ~drm_encoder_mask(conn_state->best_encoder);
236 }
237 }
238
239 if (encoder) {
240 crtc = conn_state->crtc;
241 WARN_ON(!crtc);
242 if (crtc) {
243 crtc_state = drm_atomic_get_new_crtc_state(state, crtc);
244
245 crtc_state->encoder_mask |=
246 drm_encoder_mask(encoder);
247 }
248 }
249
250 conn_state->best_encoder = encoder;
251}
252
253static void
254steal_encoder(struct drm_atomic_state *state,
255 struct drm_encoder *encoder)
256{
257 struct drm_crtc_state *crtc_state;
258 struct drm_connector *connector;
259 struct drm_connector_state *old_connector_state, *new_connector_state;
260 int i;
261
262 for_each_oldnew_connector_in_state(state, connector, old_connector_state, new_connector_state, i) {
263 struct drm_crtc *encoder_crtc;
264
265 if (new_connector_state->best_encoder != encoder)
266 continue;
267
268 encoder_crtc = old_connector_state->crtc;
269
270 DRM_DEBUG_ATOMIC("[ENCODER:%d:%s] in use on [CRTC:%d:%s], stealing it\n",
271 encoder->base.id, encoder->name,
272 encoder_crtc->base.id, encoder_crtc->name);
273
274 set_best_encoder(state, new_connector_state, NULL);
275
276 crtc_state = drm_atomic_get_new_crtc_state(state, encoder_crtc);
277 crtc_state->connectors_changed = true;
278
279 return;
280 }
281}
282
283static int
284update_connector_routing(struct drm_atomic_state *state,
285 struct drm_connector *connector,
286 struct drm_connector_state *old_connector_state,
287 struct drm_connector_state *new_connector_state)
288{
289 const struct drm_connector_helper_funcs *funcs;
290 struct drm_encoder *new_encoder;
291 struct drm_crtc_state *crtc_state;
292
293 DRM_DEBUG_ATOMIC("Updating routing for [CONNECTOR:%d:%s]\n",
294 connector->base.id,
295 connector->name);
296
297 if (old_connector_state->crtc != new_connector_state->crtc) {
298 if (old_connector_state->crtc) {
299 crtc_state = drm_atomic_get_new_crtc_state(state, old_connector_state->crtc);
300 crtc_state->connectors_changed = true;
301 }
302
303 if (new_connector_state->crtc) {
304 crtc_state = drm_atomic_get_new_crtc_state(state, new_connector_state->crtc);
305 crtc_state->connectors_changed = true;
306 }
307 }
308
309 if (!new_connector_state->crtc) {
310 DRM_DEBUG_ATOMIC("Disabling [CONNECTOR:%d:%s]\n",
311 connector->base.id,
312 connector->name);
313
314 set_best_encoder(state, new_connector_state, NULL);
315
316 return 0;
317 }
318
319 crtc_state = drm_atomic_get_new_crtc_state(state,
320 new_connector_state->crtc);
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339 if (!state->duplicated && drm_connector_is_unregistered(connector) &&
340 crtc_state->active) {
341 DRM_DEBUG_ATOMIC("[CONNECTOR:%d:%s] is not registered\n",
342 connector->base.id, connector->name);
343 return -EINVAL;
344 }
345
346 funcs = connector->helper_private;
347
348 if (funcs->atomic_best_encoder)
349 new_encoder = funcs->atomic_best_encoder(connector, state);
350 else if (funcs->best_encoder)
351 new_encoder = funcs->best_encoder(connector);
352 else
353 new_encoder = drm_connector_get_single_encoder(connector);
354
355 if (!new_encoder) {
356 DRM_DEBUG_ATOMIC("No suitable encoder found for [CONNECTOR:%d:%s]\n",
357 connector->base.id,
358 connector->name);
359 return -EINVAL;
360 }
361
362 if (!drm_encoder_crtc_ok(new_encoder, new_connector_state->crtc)) {
363 DRM_DEBUG_ATOMIC("[ENCODER:%d:%s] incompatible with [CRTC:%d:%s]\n",
364 new_encoder->base.id,
365 new_encoder->name,
366 new_connector_state->crtc->base.id,
367 new_connector_state->crtc->name);
368 return -EINVAL;
369 }
370
371 if (new_encoder == new_connector_state->best_encoder) {
372 set_best_encoder(state, new_connector_state, new_encoder);
373
374 DRM_DEBUG_ATOMIC("[CONNECTOR:%d:%s] keeps [ENCODER:%d:%s], now on [CRTC:%d:%s]\n",
375 connector->base.id,
376 connector->name,
377 new_encoder->base.id,
378 new_encoder->name,
379 new_connector_state->crtc->base.id,
380 new_connector_state->crtc->name);
381
382 return 0;
383 }
384
385 steal_encoder(state, new_encoder);
386
387 set_best_encoder(state, new_connector_state, new_encoder);
388
389 crtc_state->connectors_changed = true;
390
391 DRM_DEBUG_ATOMIC("[CONNECTOR:%d:%s] using [ENCODER:%d:%s] on [CRTC:%d:%s]\n",
392 connector->base.id,
393 connector->name,
394 new_encoder->base.id,
395 new_encoder->name,
396 new_connector_state->crtc->base.id,
397 new_connector_state->crtc->name);
398
399 return 0;
400}
401
402static int
403mode_fixup(struct drm_atomic_state *state)
404{
405 struct drm_crtc *crtc;
406 struct drm_crtc_state *new_crtc_state;
407 struct drm_connector *connector;
408 struct drm_connector_state *new_conn_state;
409 int i;
410 int ret;
411
412 for_each_new_crtc_in_state(state, crtc, new_crtc_state, i) {
413 if (!new_crtc_state->mode_changed &&
414 !new_crtc_state->connectors_changed)
415 continue;
416
417 drm_mode_copy(&new_crtc_state->adjusted_mode, &new_crtc_state->mode);
418 }
419
420 for_each_new_connector_in_state(state, connector, new_conn_state, i) {
421 const struct drm_encoder_helper_funcs *funcs;
422 struct drm_encoder *encoder;
423 struct drm_bridge *bridge;
424
425 WARN_ON(!!new_conn_state->best_encoder != !!new_conn_state->crtc);
426
427 if (!new_conn_state->crtc || !new_conn_state->best_encoder)
428 continue;
429
430 new_crtc_state =
431 drm_atomic_get_new_crtc_state(state, new_conn_state->crtc);
432
433
434
435
436
437 encoder = new_conn_state->best_encoder;
438 funcs = encoder->helper_private;
439
440 bridge = drm_bridge_chain_get_first_bridge(encoder);
441 ret = drm_atomic_bridge_chain_check(bridge,
442 new_crtc_state,
443 new_conn_state);
444 if (ret) {
445 DRM_DEBUG_ATOMIC("Bridge atomic check failed\n");
446 return ret;
447 }
448
449 if (funcs && funcs->atomic_check) {
450 ret = funcs->atomic_check(encoder, new_crtc_state,
451 new_conn_state);
452 if (ret) {
453 DRM_DEBUG_ATOMIC("[ENCODER:%d:%s] check failed\n",
454 encoder->base.id, encoder->name);
455 return ret;
456 }
457 } else if (funcs && funcs->mode_fixup) {
458 ret = funcs->mode_fixup(encoder, &new_crtc_state->mode,
459 &new_crtc_state->adjusted_mode);
460 if (!ret) {
461 DRM_DEBUG_ATOMIC("[ENCODER:%d:%s] fixup failed\n",
462 encoder->base.id, encoder->name);
463 return -EINVAL;
464 }
465 }
466 }
467
468 for_each_new_crtc_in_state(state, crtc, new_crtc_state, i) {
469 const struct drm_crtc_helper_funcs *funcs;
470
471 if (!new_crtc_state->enable)
472 continue;
473
474 if (!new_crtc_state->mode_changed &&
475 !new_crtc_state->connectors_changed)
476 continue;
477
478 funcs = crtc->helper_private;
479 if (!funcs || !funcs->mode_fixup)
480 continue;
481
482 ret = funcs->mode_fixup(crtc, &new_crtc_state->mode,
483 &new_crtc_state->adjusted_mode);
484 if (!ret) {
485 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] fixup failed\n",
486 crtc->base.id, crtc->name);
487 return -EINVAL;
488 }
489 }
490
491 return 0;
492}
493
494static enum drm_mode_status mode_valid_path(struct drm_connector *connector,
495 struct drm_encoder *encoder,
496 struct drm_crtc *crtc,
497 const struct drm_display_mode *mode)
498{
499 struct drm_bridge *bridge;
500 enum drm_mode_status ret;
501
502 ret = drm_encoder_mode_valid(encoder, mode);
503 if (ret != MODE_OK) {
504 DRM_DEBUG_ATOMIC("[ENCODER:%d:%s] mode_valid() failed\n",
505 encoder->base.id, encoder->name);
506 return ret;
507 }
508
509 bridge = drm_bridge_chain_get_first_bridge(encoder);
510 ret = drm_bridge_chain_mode_valid(bridge, &connector->display_info,
511 mode);
512 if (ret != MODE_OK) {
513 DRM_DEBUG_ATOMIC("[BRIDGE] mode_valid() failed\n");
514 return ret;
515 }
516
517 ret = drm_crtc_mode_valid(crtc, mode);
518 if (ret != MODE_OK) {
519 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] mode_valid() failed\n",
520 crtc->base.id, crtc->name);
521 return ret;
522 }
523
524 return ret;
525}
526
527static int
528mode_valid(struct drm_atomic_state *state)
529{
530 struct drm_connector_state *conn_state;
531 struct drm_connector *connector;
532 int i;
533
534 for_each_new_connector_in_state(state, connector, conn_state, i) {
535 struct drm_encoder *encoder = conn_state->best_encoder;
536 struct drm_crtc *crtc = conn_state->crtc;
537 struct drm_crtc_state *crtc_state;
538 enum drm_mode_status mode_status;
539 const struct drm_display_mode *mode;
540
541 if (!crtc || !encoder)
542 continue;
543
544 crtc_state = drm_atomic_get_new_crtc_state(state, crtc);
545 if (!crtc_state)
546 continue;
547 if (!crtc_state->mode_changed && !crtc_state->connectors_changed)
548 continue;
549
550 mode = &crtc_state->mode;
551
552 mode_status = mode_valid_path(connector, encoder, crtc, mode);
553 if (mode_status != MODE_OK)
554 return -EINVAL;
555 }
556
557 return 0;
558}
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604int
605drm_atomic_helper_check_modeset(struct drm_device *dev,
606 struct drm_atomic_state *state)
607{
608 struct drm_crtc *crtc;
609 struct drm_crtc_state *old_crtc_state, *new_crtc_state;
610 struct drm_connector *connector;
611 struct drm_connector_state *old_connector_state, *new_connector_state;
612 int i, ret;
613 unsigned connectors_mask = 0;
614
615 for_each_oldnew_crtc_in_state(state, crtc, old_crtc_state, new_crtc_state, i) {
616 bool has_connectors =
617 !!new_crtc_state->connector_mask;
618
619 WARN_ON(!drm_modeset_is_locked(&crtc->mutex));
620
621 if (!drm_mode_equal(&old_crtc_state->mode, &new_crtc_state->mode)) {
622 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] mode changed\n",
623 crtc->base.id, crtc->name);
624 new_crtc_state->mode_changed = true;
625 }
626
627 if (old_crtc_state->enable != new_crtc_state->enable) {
628 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] enable changed\n",
629 crtc->base.id, crtc->name);
630
631
632
633
634
635
636
637
638
639 new_crtc_state->mode_changed = true;
640 new_crtc_state->connectors_changed = true;
641 }
642
643 if (old_crtc_state->active != new_crtc_state->active) {
644 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] active changed\n",
645 crtc->base.id, crtc->name);
646 new_crtc_state->active_changed = true;
647 }
648
649 if (new_crtc_state->enable != has_connectors) {
650 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] enabled/connectors mismatch\n",
651 crtc->base.id, crtc->name);
652
653 return -EINVAL;
654 }
655
656 if (drm_dev_has_vblank(dev))
657 new_crtc_state->no_vblank = false;
658 else
659 new_crtc_state->no_vblank = true;
660 }
661
662 ret = handle_conflicting_encoders(state, false);
663 if (ret)
664 return ret;
665
666 for_each_oldnew_connector_in_state(state, connector, old_connector_state, new_connector_state, i) {
667 const struct drm_connector_helper_funcs *funcs = connector->helper_private;
668
669 WARN_ON(!drm_modeset_is_locked(&dev->mode_config.connection_mutex));
670
671
672
673
674
675
676 ret = update_connector_routing(state, connector,
677 old_connector_state,
678 new_connector_state);
679 if (ret)
680 return ret;
681 if (old_connector_state->crtc) {
682 new_crtc_state = drm_atomic_get_new_crtc_state(state,
683 old_connector_state->crtc);
684 if (old_connector_state->link_status !=
685 new_connector_state->link_status)
686 new_crtc_state->connectors_changed = true;
687
688 if (old_connector_state->max_requested_bpc !=
689 new_connector_state->max_requested_bpc)
690 new_crtc_state->connectors_changed = true;
691 }
692
693 if (funcs->atomic_check)
694 ret = funcs->atomic_check(connector, state);
695 if (ret)
696 return ret;
697
698 connectors_mask |= BIT(i);
699 }
700
701
702
703
704
705
706
707 for_each_oldnew_crtc_in_state(state, crtc, old_crtc_state, new_crtc_state, i) {
708 if (!drm_atomic_crtc_needs_modeset(new_crtc_state))
709 continue;
710
711 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] needs all connectors, enable: %c, active: %c\n",
712 crtc->base.id, crtc->name,
713 new_crtc_state->enable ? 'y' : 'n',
714 new_crtc_state->active ? 'y' : 'n');
715
716 ret = drm_atomic_add_affected_connectors(state, crtc);
717 if (ret != 0)
718 return ret;
719
720 ret = drm_atomic_add_affected_planes(state, crtc);
721 if (ret != 0)
722 return ret;
723 }
724
725
726
727
728
729 for_each_oldnew_connector_in_state(state, connector, old_connector_state, new_connector_state, i) {
730 const struct drm_connector_helper_funcs *funcs = connector->helper_private;
731
732 if (connectors_mask & BIT(i))
733 continue;
734
735 if (funcs->atomic_check)
736 ret = funcs->atomic_check(connector, state);
737 if (ret)
738 return ret;
739 }
740
741
742
743
744
745 for_each_oldnew_connector_in_state(state, connector,
746 old_connector_state,
747 new_connector_state, i) {
748 struct drm_encoder *encoder;
749
750 encoder = old_connector_state->best_encoder;
751 ret = drm_atomic_add_encoder_bridges(state, encoder);
752 if (ret)
753 return ret;
754
755 encoder = new_connector_state->best_encoder;
756 ret = drm_atomic_add_encoder_bridges(state, encoder);
757 if (ret)
758 return ret;
759 }
760
761 ret = mode_valid(state);
762 if (ret)
763 return ret;
764
765 return mode_fixup(state);
766}
767EXPORT_SYMBOL(drm_atomic_helper_check_modeset);
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790int drm_atomic_helper_check_plane_state(struct drm_plane_state *plane_state,
791 const struct drm_crtc_state *crtc_state,
792 int min_scale,
793 int max_scale,
794 bool can_position,
795 bool can_update_disabled)
796{
797 struct drm_framebuffer *fb = plane_state->fb;
798 struct drm_rect *src = &plane_state->src;
799 struct drm_rect *dst = &plane_state->dst;
800 unsigned int rotation = plane_state->rotation;
801 struct drm_rect clip = {};
802 int hscale, vscale;
803
804 WARN_ON(plane_state->crtc && plane_state->crtc != crtc_state->crtc);
805
806 *src = drm_plane_state_src(plane_state);
807 *dst = drm_plane_state_dest(plane_state);
808
809 if (!fb) {
810 plane_state->visible = false;
811 return 0;
812 }
813
814
815 if (WARN_ON(!plane_state->crtc)) {
816 plane_state->visible = false;
817 return 0;
818 }
819
820 if (!crtc_state->enable && !can_update_disabled) {
821 DRM_DEBUG_KMS("Cannot update plane of a disabled CRTC.\n");
822 return -EINVAL;
823 }
824
825 drm_rect_rotate(src, fb->width << 16, fb->height << 16, rotation);
826
827
828 hscale = drm_rect_calc_hscale(src, dst, min_scale, max_scale);
829 vscale = drm_rect_calc_vscale(src, dst, min_scale, max_scale);
830 if (hscale < 0 || vscale < 0) {
831 DRM_DEBUG_KMS("Invalid scaling of plane\n");
832 drm_rect_debug_print("src: ", &plane_state->src, true);
833 drm_rect_debug_print("dst: ", &plane_state->dst, false);
834 return -ERANGE;
835 }
836
837 if (crtc_state->enable)
838 drm_mode_get_hv_timing(&crtc_state->mode, &clip.x2, &clip.y2);
839
840 plane_state->visible = drm_rect_clip_scaled(src, dst, &clip);
841
842 drm_rect_rotate_inv(src, fb->width << 16, fb->height << 16, rotation);
843
844 if (!plane_state->visible)
845
846
847
848
849
850
851
852 return 0;
853
854 if (!can_position && !drm_rect_equals(dst, &clip)) {
855 DRM_DEBUG_KMS("Plane must cover entire CRTC\n");
856 drm_rect_debug_print("dst: ", dst, false);
857 drm_rect_debug_print("clip: ", &clip, false);
858 return -EINVAL;
859 }
860
861 return 0;
862}
863EXPORT_SYMBOL(drm_atomic_helper_check_plane_state);
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881int
882drm_atomic_helper_check_planes(struct drm_device *dev,
883 struct drm_atomic_state *state)
884{
885 struct drm_crtc *crtc;
886 struct drm_crtc_state *new_crtc_state;
887 struct drm_plane *plane;
888 struct drm_plane_state *new_plane_state, *old_plane_state;
889 int i, ret = 0;
890
891 for_each_oldnew_plane_in_state(state, plane, old_plane_state, new_plane_state, i) {
892 const struct drm_plane_helper_funcs *funcs;
893
894 WARN_ON(!drm_modeset_is_locked(&plane->mutex));
895
896 funcs = plane->helper_private;
897
898 drm_atomic_helper_plane_changed(state, old_plane_state, new_plane_state, plane);
899
900 drm_atomic_helper_check_plane_damage(state, new_plane_state);
901
902 if (!funcs || !funcs->atomic_check)
903 continue;
904
905 ret = funcs->atomic_check(plane, new_plane_state);
906 if (ret) {
907 DRM_DEBUG_ATOMIC("[PLANE:%d:%s] atomic driver check failed\n",
908 plane->base.id, plane->name);
909 return ret;
910 }
911 }
912
913 for_each_new_crtc_in_state(state, crtc, new_crtc_state, i) {
914 const struct drm_crtc_helper_funcs *funcs;
915
916 funcs = crtc->helper_private;
917
918 if (!funcs || !funcs->atomic_check)
919 continue;
920
921 ret = funcs->atomic_check(crtc, state);
922 if (ret) {
923 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] atomic driver check failed\n",
924 crtc->base.id, crtc->name);
925 return ret;
926 }
927 }
928
929 return ret;
930}
931EXPORT_SYMBOL(drm_atomic_helper_check_planes);
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959int drm_atomic_helper_check(struct drm_device *dev,
960 struct drm_atomic_state *state)
961{
962 int ret;
963
964 ret = drm_atomic_helper_check_modeset(dev, state);
965 if (ret)
966 return ret;
967
968 if (dev->mode_config.normalize_zpos) {
969 ret = drm_atomic_normalize_zpos(dev, state);
970 if (ret)
971 return ret;
972 }
973
974 ret = drm_atomic_helper_check_planes(dev, state);
975 if (ret)
976 return ret;
977
978 if (state->legacy_cursor_update)
979 state->async_update = !drm_atomic_helper_async_check(dev, state);
980
981 drm_self_refresh_helper_alter_state(state);
982
983 return ret;
984}
985EXPORT_SYMBOL(drm_atomic_helper_check);
986
987static bool
988crtc_needs_disable(struct drm_crtc_state *old_state,
989 struct drm_crtc_state *new_state)
990{
991
992
993
994
995 if (!new_state)
996 return drm_atomic_crtc_effectively_active(old_state);
997
998
999
1000
1001
1002
1003 return old_state->active ||
1004 (old_state->self_refresh_active && !new_state->enable) ||
1005 new_state->self_refresh_active;
1006}
1007
1008static void
1009disable_outputs(struct drm_device *dev, struct drm_atomic_state *old_state)
1010{
1011 struct drm_connector *connector;
1012 struct drm_connector_state *old_conn_state, *new_conn_state;
1013 struct drm_crtc *crtc;
1014 struct drm_crtc_state *old_crtc_state, *new_crtc_state;
1015 int i;
1016
1017 for_each_oldnew_connector_in_state(old_state, connector, old_conn_state, new_conn_state, i) {
1018 const struct drm_encoder_helper_funcs *funcs;
1019 struct drm_encoder *encoder;
1020 struct drm_bridge *bridge;
1021
1022
1023
1024 if (!old_conn_state->crtc)
1025 continue;
1026
1027 old_crtc_state = drm_atomic_get_old_crtc_state(old_state, old_conn_state->crtc);
1028
1029 if (new_conn_state->crtc)
1030 new_crtc_state = drm_atomic_get_new_crtc_state(
1031 old_state,
1032 new_conn_state->crtc);
1033 else
1034 new_crtc_state = NULL;
1035
1036 if (!crtc_needs_disable(old_crtc_state, new_crtc_state) ||
1037 !drm_atomic_crtc_needs_modeset(old_conn_state->crtc->state))
1038 continue;
1039
1040 encoder = old_conn_state->best_encoder;
1041
1042
1043
1044
1045 if (WARN_ON(!encoder))
1046 continue;
1047
1048 funcs = encoder->helper_private;
1049
1050 DRM_DEBUG_ATOMIC("disabling [ENCODER:%d:%s]\n",
1051 encoder->base.id, encoder->name);
1052
1053
1054
1055
1056
1057 bridge = drm_bridge_chain_get_first_bridge(encoder);
1058 drm_atomic_bridge_chain_disable(bridge, old_state);
1059
1060
1061 if (funcs) {
1062 if (funcs->atomic_disable)
1063 funcs->atomic_disable(encoder, old_state);
1064 else if (new_conn_state->crtc && funcs->prepare)
1065 funcs->prepare(encoder);
1066 else if (funcs->disable)
1067 funcs->disable(encoder);
1068 else if (funcs->dpms)
1069 funcs->dpms(encoder, DRM_MODE_DPMS_OFF);
1070 }
1071
1072 drm_atomic_bridge_chain_post_disable(bridge, old_state);
1073 }
1074
1075 for_each_oldnew_crtc_in_state(old_state, crtc, old_crtc_state, new_crtc_state, i) {
1076 const struct drm_crtc_helper_funcs *funcs;
1077 int ret;
1078
1079
1080 if (!drm_atomic_crtc_needs_modeset(new_crtc_state))
1081 continue;
1082
1083 if (!crtc_needs_disable(old_crtc_state, new_crtc_state))
1084 continue;
1085
1086 funcs = crtc->helper_private;
1087
1088 DRM_DEBUG_ATOMIC("disabling [CRTC:%d:%s]\n",
1089 crtc->base.id, crtc->name);
1090
1091
1092
1093 if (new_crtc_state->enable && funcs->prepare)
1094 funcs->prepare(crtc);
1095 else if (funcs->atomic_disable)
1096 funcs->atomic_disable(crtc, old_state);
1097 else if (funcs->disable)
1098 funcs->disable(crtc);
1099 else if (funcs->dpms)
1100 funcs->dpms(crtc, DRM_MODE_DPMS_OFF);
1101
1102 if (!drm_dev_has_vblank(dev))
1103 continue;
1104
1105 ret = drm_crtc_vblank_get(crtc);
1106 WARN_ONCE(ret != -EINVAL, "driver forgot to call drm_crtc_vblank_off()\n");
1107 if (ret == 0)
1108 drm_crtc_vblank_put(crtc);
1109 }
1110}
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129void
1130drm_atomic_helper_update_legacy_modeset_state(struct drm_device *dev,
1131 struct drm_atomic_state *old_state)
1132{
1133 struct drm_connector *connector;
1134 struct drm_connector_state *old_conn_state, *new_conn_state;
1135 struct drm_crtc *crtc;
1136 struct drm_crtc_state *new_crtc_state;
1137 int i;
1138
1139
1140 for_each_oldnew_connector_in_state(old_state, connector, old_conn_state, new_conn_state, i) {
1141 if (connector->encoder) {
1142 WARN_ON(!connector->encoder->crtc);
1143
1144 connector->encoder->crtc = NULL;
1145 connector->encoder = NULL;
1146 }
1147
1148 crtc = new_conn_state->crtc;
1149 if ((!crtc && old_conn_state->crtc) ||
1150 (crtc && drm_atomic_crtc_needs_modeset(crtc->state))) {
1151 int mode = DRM_MODE_DPMS_OFF;
1152
1153 if (crtc && crtc->state->active)
1154 mode = DRM_MODE_DPMS_ON;
1155
1156 connector->dpms = mode;
1157 }
1158 }
1159
1160
1161 for_each_new_connector_in_state(old_state, connector, new_conn_state, i) {
1162 if (!new_conn_state->crtc)
1163 continue;
1164
1165 if (WARN_ON(!new_conn_state->best_encoder))
1166 continue;
1167
1168 connector->encoder = new_conn_state->best_encoder;
1169 connector->encoder->crtc = new_conn_state->crtc;
1170 }
1171
1172
1173 for_each_new_crtc_in_state(old_state, crtc, new_crtc_state, i) {
1174 struct drm_plane *primary = crtc->primary;
1175 struct drm_plane_state *new_plane_state;
1176
1177 crtc->mode = new_crtc_state->mode;
1178 crtc->enabled = new_crtc_state->enable;
1179
1180 new_plane_state =
1181 drm_atomic_get_new_plane_state(old_state, primary);
1182
1183 if (new_plane_state && new_plane_state->crtc == crtc) {
1184 crtc->x = new_plane_state->src_x >> 16;
1185 crtc->y = new_plane_state->src_y >> 16;
1186 }
1187 }
1188}
1189EXPORT_SYMBOL(drm_atomic_helper_update_legacy_modeset_state);
1190
1191
1192
1193
1194
1195
1196
1197
1198void drm_atomic_helper_calc_timestamping_constants(struct drm_atomic_state *state)
1199{
1200 struct drm_crtc_state *new_crtc_state;
1201 struct drm_crtc *crtc;
1202 int i;
1203
1204 for_each_new_crtc_in_state(state, crtc, new_crtc_state, i) {
1205 if (new_crtc_state->enable)
1206 drm_calc_timestamping_constants(crtc,
1207 &new_crtc_state->adjusted_mode);
1208 }
1209}
1210EXPORT_SYMBOL(drm_atomic_helper_calc_timestamping_constants);
1211
1212static void
1213crtc_set_mode(struct drm_device *dev, struct drm_atomic_state *old_state)
1214{
1215 struct drm_crtc *crtc;
1216 struct drm_crtc_state *new_crtc_state;
1217 struct drm_connector *connector;
1218 struct drm_connector_state *new_conn_state;
1219 int i;
1220
1221 for_each_new_crtc_in_state(old_state, crtc, new_crtc_state, i) {
1222 const struct drm_crtc_helper_funcs *funcs;
1223
1224 if (!new_crtc_state->mode_changed)
1225 continue;
1226
1227 funcs = crtc->helper_private;
1228
1229 if (new_crtc_state->enable && funcs->mode_set_nofb) {
1230 DRM_DEBUG_ATOMIC("modeset on [CRTC:%d:%s]\n",
1231 crtc->base.id, crtc->name);
1232
1233 funcs->mode_set_nofb(crtc);
1234 }
1235 }
1236
1237 for_each_new_connector_in_state(old_state, connector, new_conn_state, i) {
1238 const struct drm_encoder_helper_funcs *funcs;
1239 struct drm_encoder *encoder;
1240 struct drm_display_mode *mode, *adjusted_mode;
1241 struct drm_bridge *bridge;
1242
1243 if (!new_conn_state->best_encoder)
1244 continue;
1245
1246 encoder = new_conn_state->best_encoder;
1247 funcs = encoder->helper_private;
1248 new_crtc_state = new_conn_state->crtc->state;
1249 mode = &new_crtc_state->mode;
1250 adjusted_mode = &new_crtc_state->adjusted_mode;
1251
1252 if (!new_crtc_state->mode_changed)
1253 continue;
1254
1255 DRM_DEBUG_ATOMIC("modeset on [ENCODER:%d:%s]\n",
1256 encoder->base.id, encoder->name);
1257
1258
1259
1260
1261
1262 if (funcs && funcs->atomic_mode_set) {
1263 funcs->atomic_mode_set(encoder, new_crtc_state,
1264 new_conn_state);
1265 } else if (funcs && funcs->mode_set) {
1266 funcs->mode_set(encoder, mode, adjusted_mode);
1267 }
1268
1269 bridge = drm_bridge_chain_get_first_bridge(encoder);
1270 drm_bridge_chain_mode_set(bridge, mode, adjusted_mode);
1271 }
1272}
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288void drm_atomic_helper_commit_modeset_disables(struct drm_device *dev,
1289 struct drm_atomic_state *old_state)
1290{
1291 disable_outputs(dev, old_state);
1292
1293 drm_atomic_helper_update_legacy_modeset_state(dev, old_state);
1294 drm_atomic_helper_calc_timestamping_constants(old_state);
1295
1296 crtc_set_mode(dev, old_state);
1297}
1298EXPORT_SYMBOL(drm_atomic_helper_commit_modeset_disables);
1299
1300static void drm_atomic_helper_commit_writebacks(struct drm_device *dev,
1301 struct drm_atomic_state *old_state)
1302{
1303 struct drm_connector *connector;
1304 struct drm_connector_state *new_conn_state;
1305 int i;
1306
1307 for_each_new_connector_in_state(old_state, connector, new_conn_state, i) {
1308 const struct drm_connector_helper_funcs *funcs;
1309
1310 funcs = connector->helper_private;
1311 if (!funcs->atomic_commit)
1312 continue;
1313
1314 if (new_conn_state->writeback_job && new_conn_state->writeback_job->fb) {
1315 WARN_ON(connector->connector_type != DRM_MODE_CONNECTOR_WRITEBACK);
1316 funcs->atomic_commit(connector, old_state);
1317 }
1318 }
1319}
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335void drm_atomic_helper_commit_modeset_enables(struct drm_device *dev,
1336 struct drm_atomic_state *old_state)
1337{
1338 struct drm_crtc *crtc;
1339 struct drm_crtc_state *old_crtc_state;
1340 struct drm_crtc_state *new_crtc_state;
1341 struct drm_connector *connector;
1342 struct drm_connector_state *new_conn_state;
1343 int i;
1344
1345 for_each_oldnew_crtc_in_state(old_state, crtc, old_crtc_state, new_crtc_state, i) {
1346 const struct drm_crtc_helper_funcs *funcs;
1347
1348
1349 if (!drm_atomic_crtc_needs_modeset(new_crtc_state))
1350 continue;
1351
1352 if (!new_crtc_state->active)
1353 continue;
1354
1355 funcs = crtc->helper_private;
1356
1357 if (new_crtc_state->enable) {
1358 DRM_DEBUG_ATOMIC("enabling [CRTC:%d:%s]\n",
1359 crtc->base.id, crtc->name);
1360 if (funcs->atomic_enable)
1361 funcs->atomic_enable(crtc, old_state);
1362 else if (funcs->commit)
1363 funcs->commit(crtc);
1364 }
1365 }
1366
1367 for_each_new_connector_in_state(old_state, connector, new_conn_state, i) {
1368 const struct drm_encoder_helper_funcs *funcs;
1369 struct drm_encoder *encoder;
1370 struct drm_bridge *bridge;
1371
1372 if (!new_conn_state->best_encoder)
1373 continue;
1374
1375 if (!new_conn_state->crtc->state->active ||
1376 !drm_atomic_crtc_needs_modeset(new_conn_state->crtc->state))
1377 continue;
1378
1379 encoder = new_conn_state->best_encoder;
1380 funcs = encoder->helper_private;
1381
1382 DRM_DEBUG_ATOMIC("enabling [ENCODER:%d:%s]\n",
1383 encoder->base.id, encoder->name);
1384
1385
1386
1387
1388
1389 bridge = drm_bridge_chain_get_first_bridge(encoder);
1390 drm_atomic_bridge_chain_pre_enable(bridge, old_state);
1391
1392 if (funcs) {
1393 if (funcs->atomic_enable)
1394 funcs->atomic_enable(encoder, old_state);
1395 else if (funcs->enable)
1396 funcs->enable(encoder);
1397 else if (funcs->commit)
1398 funcs->commit(encoder);
1399 }
1400
1401 drm_atomic_bridge_chain_enable(bridge, old_state);
1402 }
1403
1404 drm_atomic_helper_commit_writebacks(dev, old_state);
1405}
1406EXPORT_SYMBOL(drm_atomic_helper_commit_modeset_enables);
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429int drm_atomic_helper_wait_for_fences(struct drm_device *dev,
1430 struct drm_atomic_state *state,
1431 bool pre_swap)
1432{
1433 struct drm_plane *plane;
1434 struct drm_plane_state *new_plane_state;
1435 int i, ret;
1436
1437 for_each_new_plane_in_state(state, plane, new_plane_state, i) {
1438 if (!new_plane_state->fence)
1439 continue;
1440
1441 WARN_ON(!new_plane_state->fb);
1442
1443
1444
1445
1446
1447
1448 ret = dma_fence_wait(new_plane_state->fence, pre_swap);
1449 if (ret)
1450 return ret;
1451
1452 dma_fence_put(new_plane_state->fence);
1453 new_plane_state->fence = NULL;
1454 }
1455
1456 return 0;
1457}
1458EXPORT_SYMBOL(drm_atomic_helper_wait_for_fences);
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475void
1476drm_atomic_helper_wait_for_vblanks(struct drm_device *dev,
1477 struct drm_atomic_state *old_state)
1478{
1479 struct drm_crtc *crtc;
1480 struct drm_crtc_state *old_crtc_state, *new_crtc_state;
1481 int i, ret;
1482 unsigned crtc_mask = 0;
1483
1484
1485
1486
1487
1488 if (old_state->legacy_cursor_update)
1489 return;
1490
1491 for_each_oldnew_crtc_in_state(old_state, crtc, old_crtc_state, new_crtc_state, i) {
1492 if (!new_crtc_state->active)
1493 continue;
1494
1495 ret = drm_crtc_vblank_get(crtc);
1496 if (ret != 0)
1497 continue;
1498
1499 crtc_mask |= drm_crtc_mask(crtc);
1500 old_state->crtcs[i].last_vblank_count = drm_crtc_vblank_count(crtc);
1501 }
1502
1503 for_each_old_crtc_in_state(old_state, crtc, old_crtc_state, i) {
1504 if (!(crtc_mask & drm_crtc_mask(crtc)))
1505 continue;
1506
1507 ret = wait_event_timeout(dev->vblank[i].queue,
1508 old_state->crtcs[i].last_vblank_count !=
1509 drm_crtc_vblank_count(crtc),
1510 msecs_to_jiffies(100));
1511
1512 WARN(!ret, "[CRTC:%d:%s] vblank wait timed out\n",
1513 crtc->base.id, crtc->name);
1514
1515 drm_crtc_vblank_put(crtc);
1516 }
1517}
1518EXPORT_SYMBOL(drm_atomic_helper_wait_for_vblanks);
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535void drm_atomic_helper_wait_for_flip_done(struct drm_device *dev,
1536 struct drm_atomic_state *old_state)
1537{
1538 struct drm_crtc *crtc;
1539 int i;
1540
1541 for (i = 0; i < dev->mode_config.num_crtc; i++) {
1542 struct drm_crtc_commit *commit = old_state->crtcs[i].commit;
1543 int ret;
1544
1545 crtc = old_state->crtcs[i].ptr;
1546
1547 if (!crtc || !commit)
1548 continue;
1549
1550 ret = wait_for_completion_timeout(&commit->flip_done, 10 * HZ);
1551 if (ret == 0)
1552 DRM_ERROR("[CRTC:%d:%s] flip_done timed out\n",
1553 crtc->base.id, crtc->name);
1554 }
1555
1556 if (old_state->fake_commit)
1557 complete_all(&old_state->fake_commit->flip_done);
1558}
1559EXPORT_SYMBOL(drm_atomic_helper_wait_for_flip_done);
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574void drm_atomic_helper_commit_tail(struct drm_atomic_state *old_state)
1575{
1576 struct drm_device *dev = old_state->dev;
1577
1578 drm_atomic_helper_commit_modeset_disables(dev, old_state);
1579
1580 drm_atomic_helper_commit_planes(dev, old_state, 0);
1581
1582 drm_atomic_helper_commit_modeset_enables(dev, old_state);
1583
1584 drm_atomic_helper_fake_vblank(old_state);
1585
1586 drm_atomic_helper_commit_hw_done(old_state);
1587
1588 drm_atomic_helper_wait_for_vblanks(dev, old_state);
1589
1590 drm_atomic_helper_cleanup_planes(dev, old_state);
1591}
1592EXPORT_SYMBOL(drm_atomic_helper_commit_tail);
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604void drm_atomic_helper_commit_tail_rpm(struct drm_atomic_state *old_state)
1605{
1606 struct drm_device *dev = old_state->dev;
1607
1608 drm_atomic_helper_commit_modeset_disables(dev, old_state);
1609
1610 drm_atomic_helper_commit_modeset_enables(dev, old_state);
1611
1612 drm_atomic_helper_commit_planes(dev, old_state,
1613 DRM_PLANE_COMMIT_ACTIVE_ONLY);
1614
1615 drm_atomic_helper_fake_vblank(old_state);
1616
1617 drm_atomic_helper_commit_hw_done(old_state);
1618
1619 drm_atomic_helper_wait_for_vblanks(dev, old_state);
1620
1621 drm_atomic_helper_cleanup_planes(dev, old_state);
1622}
1623EXPORT_SYMBOL(drm_atomic_helper_commit_tail_rpm);
1624
1625static void commit_tail(struct drm_atomic_state *old_state)
1626{
1627 struct drm_device *dev = old_state->dev;
1628 const struct drm_mode_config_helper_funcs *funcs;
1629 struct drm_crtc_state *new_crtc_state;
1630 struct drm_crtc *crtc;
1631 ktime_t start;
1632 s64 commit_time_ms;
1633 unsigned int i, new_self_refresh_mask = 0;
1634
1635 funcs = dev->mode_config.helper_private;
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647 start = ktime_get();
1648
1649 drm_atomic_helper_wait_for_fences(dev, old_state, false);
1650
1651 drm_atomic_helper_wait_for_dependencies(old_state);
1652
1653
1654
1655
1656
1657
1658 for_each_new_crtc_in_state(old_state, crtc, new_crtc_state, i)
1659 if (new_crtc_state->self_refresh_active)
1660 new_self_refresh_mask |= BIT(i);
1661
1662 if (funcs && funcs->atomic_commit_tail)
1663 funcs->atomic_commit_tail(old_state);
1664 else
1665 drm_atomic_helper_commit_tail(old_state);
1666
1667 commit_time_ms = ktime_ms_delta(ktime_get(), start);
1668 if (commit_time_ms > 0)
1669 drm_self_refresh_helper_update_avg_times(old_state,
1670 (unsigned long)commit_time_ms,
1671 new_self_refresh_mask);
1672
1673 drm_atomic_helper_commit_cleanup_done(old_state);
1674
1675 drm_atomic_state_put(old_state);
1676}
1677
1678static void commit_work(struct work_struct *work)
1679{
1680 struct drm_atomic_state *state = container_of(work,
1681 struct drm_atomic_state,
1682 commit_work);
1683 commit_tail(state);
1684}
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699int drm_atomic_helper_async_check(struct drm_device *dev,
1700 struct drm_atomic_state *state)
1701{
1702 struct drm_crtc *crtc;
1703 struct drm_crtc_state *crtc_state;
1704 struct drm_plane *plane = NULL;
1705 struct drm_plane_state *old_plane_state = NULL;
1706 struct drm_plane_state *new_plane_state = NULL;
1707 const struct drm_plane_helper_funcs *funcs;
1708 int i, n_planes = 0;
1709
1710 for_each_new_crtc_in_state(state, crtc, crtc_state, i) {
1711 if (drm_atomic_crtc_needs_modeset(crtc_state))
1712 return -EINVAL;
1713 }
1714
1715 for_each_oldnew_plane_in_state(state, plane, old_plane_state, new_plane_state, i)
1716 n_planes++;
1717
1718
1719 if (n_planes != 1)
1720 return -EINVAL;
1721
1722 if (!new_plane_state->crtc ||
1723 old_plane_state->crtc != new_plane_state->crtc)
1724 return -EINVAL;
1725
1726 funcs = plane->helper_private;
1727 if (!funcs->atomic_async_update)
1728 return -EINVAL;
1729
1730 if (new_plane_state->fence)
1731 return -EINVAL;
1732
1733
1734
1735
1736
1737
1738 if (old_plane_state->commit &&
1739 !try_wait_for_completion(&old_plane_state->commit->hw_done)) {
1740 DRM_DEBUG_ATOMIC("[PLANE:%d:%s] inflight previous commit preventing async commit\n",
1741 plane->base.id, plane->name);
1742 return -EBUSY;
1743 }
1744
1745 return funcs->atomic_async_check(plane, new_plane_state);
1746}
1747EXPORT_SYMBOL(drm_atomic_helper_async_check);
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762void drm_atomic_helper_async_commit(struct drm_device *dev,
1763 struct drm_atomic_state *state)
1764{
1765 struct drm_plane *plane;
1766 struct drm_plane_state *plane_state;
1767 const struct drm_plane_helper_funcs *funcs;
1768 int i;
1769
1770 for_each_new_plane_in_state(state, plane, plane_state, i) {
1771 struct drm_framebuffer *new_fb = plane_state->fb;
1772 struct drm_framebuffer *old_fb = plane->state->fb;
1773
1774 funcs = plane->helper_private;
1775 funcs->atomic_async_update(plane, plane_state);
1776
1777
1778
1779
1780
1781
1782 WARN_ON_ONCE(plane->state->fb != new_fb);
1783 WARN_ON_ONCE(plane->state->crtc_x != plane_state->crtc_x);
1784 WARN_ON_ONCE(plane->state->crtc_y != plane_state->crtc_y);
1785 WARN_ON_ONCE(plane->state->src_x != plane_state->src_x);
1786 WARN_ON_ONCE(plane->state->src_y != plane_state->src_y);
1787
1788
1789
1790
1791
1792 WARN_ON_ONCE(plane_state->fb != old_fb);
1793 }
1794}
1795EXPORT_SYMBOL(drm_atomic_helper_async_commit);
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813
1814
1815int drm_atomic_helper_commit(struct drm_device *dev,
1816 struct drm_atomic_state *state,
1817 bool nonblock)
1818{
1819 int ret;
1820
1821 if (state->async_update) {
1822 ret = drm_atomic_helper_prepare_planes(dev, state);
1823 if (ret)
1824 return ret;
1825
1826 drm_atomic_helper_async_commit(dev, state);
1827 drm_atomic_helper_cleanup_planes(dev, state);
1828
1829 return 0;
1830 }
1831
1832 ret = drm_atomic_helper_setup_commit(state, nonblock);
1833 if (ret)
1834 return ret;
1835
1836 INIT_WORK(&state->commit_work, commit_work);
1837
1838 ret = drm_atomic_helper_prepare_planes(dev, state);
1839 if (ret)
1840 return ret;
1841
1842 if (!nonblock) {
1843 ret = drm_atomic_helper_wait_for_fences(dev, state, true);
1844 if (ret)
1845 goto err;
1846 }
1847
1848
1849
1850
1851
1852
1853
1854 ret = drm_atomic_helper_swap_state(state, true);
1855 if (ret)
1856 goto err;
1857
1858
1859
1860
1861
1862
1863
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874
1875
1876
1877
1878 drm_atomic_state_get(state);
1879 if (nonblock)
1880 queue_work(system_unbound_wq, &state->commit_work);
1881 else
1882 commit_tail(state);
1883
1884 return 0;
1885
1886err:
1887 drm_atomic_helper_cleanup_planes(dev, state);
1888 return ret;
1889}
1890EXPORT_SYMBOL(drm_atomic_helper_commit);
1891
1892
1893
1894
1895
1896
1897
1898
1899
1900
1901
1902
1903
1904
1905
1906
1907
1908
1909
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920
1921
1922
1923
1924
1925
1926
1927
1928
1929
1930
1931
1932
1933
1934
1935
1936
1937
1938
1939
1940
1941
1942
1943
1944
1945static int stall_checks(struct drm_crtc *crtc, bool nonblock)
1946{
1947 struct drm_crtc_commit *commit, *stall_commit = NULL;
1948 bool completed = true;
1949 int i;
1950 long ret = 0;
1951
1952 spin_lock(&crtc->commit_lock);
1953 i = 0;
1954 list_for_each_entry(commit, &crtc->commit_list, commit_entry) {
1955 if (i == 0) {
1956 completed = try_wait_for_completion(&commit->flip_done);
1957
1958
1959 if (!completed && nonblock) {
1960 spin_unlock(&crtc->commit_lock);
1961 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] busy with a previous commit\n",
1962 crtc->base.id, crtc->name);
1963
1964 return -EBUSY;
1965 }
1966 } else if (i == 1) {
1967 stall_commit = drm_crtc_commit_get(commit);
1968 break;
1969 }
1970
1971 i++;
1972 }
1973 spin_unlock(&crtc->commit_lock);
1974
1975 if (!stall_commit)
1976 return 0;
1977
1978
1979
1980
1981 ret = wait_for_completion_interruptible_timeout(&stall_commit->cleanup_done,
1982 10*HZ);
1983 if (ret == 0)
1984 DRM_ERROR("[CRTC:%d:%s] cleanup_done timed out\n",
1985 crtc->base.id, crtc->name);
1986
1987 drm_crtc_commit_put(stall_commit);
1988
1989 return ret < 0 ? ret : 0;
1990}
1991
1992static void release_crtc_commit(struct completion *completion)
1993{
1994 struct drm_crtc_commit *commit = container_of(completion,
1995 typeof(*commit),
1996 flip_done);
1997
1998 drm_crtc_commit_put(commit);
1999}
2000
2001static void init_commit(struct drm_crtc_commit *commit, struct drm_crtc *crtc)
2002{
2003 init_completion(&commit->flip_done);
2004 init_completion(&commit->hw_done);
2005 init_completion(&commit->cleanup_done);
2006 INIT_LIST_HEAD(&commit->commit_entry);
2007 kref_init(&commit->ref);
2008 commit->crtc = crtc;
2009}
2010
2011static struct drm_crtc_commit *
2012crtc_or_fake_commit(struct drm_atomic_state *state, struct drm_crtc *crtc)
2013{
2014 if (crtc) {
2015 struct drm_crtc_state *new_crtc_state;
2016
2017 new_crtc_state = drm_atomic_get_new_crtc_state(state, crtc);
2018
2019 return new_crtc_state->commit;
2020 }
2021
2022 if (!state->fake_commit) {
2023 state->fake_commit = kzalloc(sizeof(*state->fake_commit), GFP_KERNEL);
2024 if (!state->fake_commit)
2025 return NULL;
2026
2027 init_commit(state->fake_commit, NULL);
2028 }
2029
2030 return state->fake_commit;
2031}
2032
2033
2034
2035
2036
2037
2038
2039
2040
2041
2042
2043
2044
2045
2046
2047
2048
2049
2050
2051
2052
2053
2054
2055
2056
2057
2058
2059
2060
2061
2062
2063
2064
2065
2066
2067
2068
2069
2070
2071
2072
2073
2074
2075
2076int drm_atomic_helper_setup_commit(struct drm_atomic_state *state,
2077 bool nonblock)
2078{
2079 struct drm_crtc *crtc;
2080 struct drm_crtc_state *old_crtc_state, *new_crtc_state;
2081 struct drm_connector *conn;
2082 struct drm_connector_state *old_conn_state, *new_conn_state;
2083 struct drm_plane *plane;
2084 struct drm_plane_state *old_plane_state, *new_plane_state;
2085 struct drm_crtc_commit *commit;
2086 int i, ret;
2087
2088 for_each_oldnew_crtc_in_state(state, crtc, old_crtc_state, new_crtc_state, i) {
2089 commit = kzalloc(sizeof(*commit), GFP_KERNEL);
2090 if (!commit)
2091 return -ENOMEM;
2092
2093 init_commit(commit, crtc);
2094
2095 new_crtc_state->commit = commit;
2096
2097 ret = stall_checks(crtc, nonblock);
2098 if (ret)
2099 return ret;
2100
2101
2102
2103
2104 if (!old_crtc_state->active && !new_crtc_state->active) {
2105 complete_all(&commit->flip_done);
2106 continue;
2107 }
2108
2109
2110 if (state->legacy_cursor_update) {
2111 complete_all(&commit->flip_done);
2112 continue;
2113 }
2114
2115 if (!new_crtc_state->event) {
2116 commit->event = kzalloc(sizeof(*commit->event),
2117 GFP_KERNEL);
2118 if (!commit->event)
2119 return -ENOMEM;
2120
2121 new_crtc_state->event = commit->event;
2122 }
2123
2124 new_crtc_state->event->base.completion = &commit->flip_done;
2125 new_crtc_state->event->base.completion_release = release_crtc_commit;
2126 drm_crtc_commit_get(commit);
2127
2128 commit->abort_completion = true;
2129
2130 state->crtcs[i].commit = commit;
2131 drm_crtc_commit_get(commit);
2132 }
2133
2134 for_each_oldnew_connector_in_state(state, conn, old_conn_state, new_conn_state, i) {
2135
2136
2137 if (nonblock && old_conn_state->commit &&
2138 !try_wait_for_completion(&old_conn_state->commit->flip_done)) {
2139 DRM_DEBUG_ATOMIC("[CONNECTOR:%d:%s] busy with a previous commit\n",
2140 conn->base.id, conn->name);
2141
2142 return -EBUSY;
2143 }
2144
2145
2146 commit = crtc_or_fake_commit(state, new_conn_state->crtc ?: old_conn_state->crtc);
2147 if (!commit)
2148 return -ENOMEM;
2149
2150 new_conn_state->commit = drm_crtc_commit_get(commit);
2151 }
2152
2153 for_each_oldnew_plane_in_state(state, plane, old_plane_state, new_plane_state, i) {
2154
2155
2156 if (nonblock && old_plane_state->commit &&
2157 !try_wait_for_completion(&old_plane_state->commit->flip_done)) {
2158 DRM_DEBUG_ATOMIC("[PLANE:%d:%s] busy with a previous commit\n",
2159 plane->base.id, plane->name);
2160
2161 return -EBUSY;
2162 }
2163
2164
2165 commit = crtc_or_fake_commit(state, new_plane_state->crtc ?: old_plane_state->crtc);
2166 if (!commit)
2167 return -ENOMEM;
2168
2169 new_plane_state->commit = drm_crtc_commit_get(commit);
2170 }
2171
2172 return 0;
2173}
2174EXPORT_SYMBOL(drm_atomic_helper_setup_commit);
2175
2176
2177
2178
2179
2180
2181
2182
2183
2184
2185
2186
2187
2188void drm_atomic_helper_wait_for_dependencies(struct drm_atomic_state *old_state)
2189{
2190 struct drm_crtc *crtc;
2191 struct drm_crtc_state *old_crtc_state;
2192 struct drm_plane *plane;
2193 struct drm_plane_state *old_plane_state;
2194 struct drm_connector *conn;
2195 struct drm_connector_state *old_conn_state;
2196 struct drm_crtc_commit *commit;
2197 int i;
2198 long ret;
2199
2200 for_each_old_crtc_in_state(old_state, crtc, old_crtc_state, i) {
2201 commit = old_crtc_state->commit;
2202
2203 if (!commit)
2204 continue;
2205
2206 ret = wait_for_completion_timeout(&commit->hw_done,
2207 10*HZ);
2208 if (ret == 0)
2209 DRM_ERROR("[CRTC:%d:%s] hw_done timed out\n",
2210 crtc->base.id, crtc->name);
2211
2212
2213
2214 ret = wait_for_completion_timeout(&commit->flip_done,
2215 10*HZ);
2216 if (ret == 0)
2217 DRM_ERROR("[CRTC:%d:%s] flip_done timed out\n",
2218 crtc->base.id, crtc->name);
2219 }
2220
2221 for_each_old_connector_in_state(old_state, conn, old_conn_state, i) {
2222 commit = old_conn_state->commit;
2223
2224 if (!commit)
2225 continue;
2226
2227 ret = wait_for_completion_timeout(&commit->hw_done,
2228 10*HZ);
2229 if (ret == 0)
2230 DRM_ERROR("[CONNECTOR:%d:%s] hw_done timed out\n",
2231 conn->base.id, conn->name);
2232
2233
2234
2235 ret = wait_for_completion_timeout(&commit->flip_done,
2236 10*HZ);
2237 if (ret == 0)
2238 DRM_ERROR("[CONNECTOR:%d:%s] flip_done timed out\n",
2239 conn->base.id, conn->name);
2240 }
2241
2242 for_each_old_plane_in_state(old_state, plane, old_plane_state, i) {
2243 commit = old_plane_state->commit;
2244
2245 if (!commit)
2246 continue;
2247
2248 ret = wait_for_completion_timeout(&commit->hw_done,
2249 10*HZ);
2250 if (ret == 0)
2251 DRM_ERROR("[PLANE:%d:%s] hw_done timed out\n",
2252 plane->base.id, plane->name);
2253
2254
2255
2256 ret = wait_for_completion_timeout(&commit->flip_done,
2257 10*HZ);
2258 if (ret == 0)
2259 DRM_ERROR("[PLANE:%d:%s] flip_done timed out\n",
2260 plane->base.id, plane->name);
2261 }
2262}
2263EXPORT_SYMBOL(drm_atomic_helper_wait_for_dependencies);
2264
2265
2266
2267
2268
2269
2270
2271
2272
2273
2274
2275
2276
2277
2278
2279
2280
2281
2282
2283void drm_atomic_helper_fake_vblank(struct drm_atomic_state *old_state)
2284{
2285 struct drm_crtc_state *new_crtc_state;
2286 struct drm_crtc *crtc;
2287 int i;
2288
2289 for_each_new_crtc_in_state(old_state, crtc, new_crtc_state, i) {
2290 unsigned long flags;
2291
2292 if (!new_crtc_state->no_vblank)
2293 continue;
2294
2295 spin_lock_irqsave(&old_state->dev->event_lock, flags);
2296 if (new_crtc_state->event) {
2297 drm_crtc_send_vblank_event(crtc,
2298 new_crtc_state->event);
2299 new_crtc_state->event = NULL;
2300 }
2301 spin_unlock_irqrestore(&old_state->dev->event_lock, flags);
2302 }
2303}
2304EXPORT_SYMBOL(drm_atomic_helper_fake_vblank);
2305
2306
2307
2308
2309
2310
2311
2312
2313
2314
2315
2316
2317
2318
2319
2320
2321void drm_atomic_helper_commit_hw_done(struct drm_atomic_state *old_state)
2322{
2323 struct drm_crtc *crtc;
2324 struct drm_crtc_state *old_crtc_state, *new_crtc_state;
2325 struct drm_crtc_commit *commit;
2326 int i;
2327
2328 for_each_oldnew_crtc_in_state(old_state, crtc, old_crtc_state, new_crtc_state, i) {
2329 commit = new_crtc_state->commit;
2330 if (!commit)
2331 continue;
2332
2333
2334
2335
2336
2337
2338 if (old_crtc_state->commit)
2339 drm_crtc_commit_put(old_crtc_state->commit);
2340
2341 old_crtc_state->commit = drm_crtc_commit_get(commit);
2342
2343
2344 WARN_ON(new_crtc_state->event);
2345 complete_all(&commit->hw_done);
2346 }
2347
2348 if (old_state->fake_commit) {
2349 complete_all(&old_state->fake_commit->hw_done);
2350 complete_all(&old_state->fake_commit->flip_done);
2351 }
2352}
2353EXPORT_SYMBOL(drm_atomic_helper_commit_hw_done);
2354
2355
2356
2357
2358
2359
2360
2361
2362
2363
2364
2365
2366void drm_atomic_helper_commit_cleanup_done(struct drm_atomic_state *old_state)
2367{
2368 struct drm_crtc *crtc;
2369 struct drm_crtc_state *old_crtc_state;
2370 struct drm_crtc_commit *commit;
2371 int i;
2372
2373 for_each_old_crtc_in_state(old_state, crtc, old_crtc_state, i) {
2374 commit = old_crtc_state->commit;
2375 if (WARN_ON(!commit))
2376 continue;
2377
2378 complete_all(&commit->cleanup_done);
2379 WARN_ON(!try_wait_for_completion(&commit->hw_done));
2380
2381 spin_lock(&crtc->commit_lock);
2382 list_del(&commit->commit_entry);
2383 spin_unlock(&crtc->commit_lock);
2384 }
2385
2386 if (old_state->fake_commit) {
2387 complete_all(&old_state->fake_commit->cleanup_done);
2388 WARN_ON(!try_wait_for_completion(&old_state->fake_commit->hw_done));
2389 }
2390}
2391EXPORT_SYMBOL(drm_atomic_helper_commit_cleanup_done);
2392
2393
2394
2395
2396
2397
2398
2399
2400
2401
2402
2403
2404
2405
2406int drm_atomic_helper_prepare_planes(struct drm_device *dev,
2407 struct drm_atomic_state *state)
2408{
2409 struct drm_connector *connector;
2410 struct drm_connector_state *new_conn_state;
2411 struct drm_plane *plane;
2412 struct drm_plane_state *new_plane_state;
2413 int ret, i, j;
2414
2415 for_each_new_connector_in_state(state, connector, new_conn_state, i) {
2416 if (!new_conn_state->writeback_job)
2417 continue;
2418
2419 ret = drm_writeback_prepare_job(new_conn_state->writeback_job);
2420 if (ret < 0)
2421 return ret;
2422 }
2423
2424 for_each_new_plane_in_state(state, plane, new_plane_state, i) {
2425 const struct drm_plane_helper_funcs *funcs;
2426
2427 funcs = plane->helper_private;
2428
2429 if (funcs->prepare_fb) {
2430 ret = funcs->prepare_fb(plane, new_plane_state);
2431 if (ret)
2432 goto fail;
2433 }
2434 }
2435
2436 return 0;
2437
2438fail:
2439 for_each_new_plane_in_state(state, plane, new_plane_state, j) {
2440 const struct drm_plane_helper_funcs *funcs;
2441
2442 if (j >= i)
2443 continue;
2444
2445 funcs = plane->helper_private;
2446
2447 if (funcs->cleanup_fb)
2448 funcs->cleanup_fb(plane, new_plane_state);
2449 }
2450
2451 return ret;
2452}
2453EXPORT_SYMBOL(drm_atomic_helper_prepare_planes);
2454
2455static bool plane_crtc_active(const struct drm_plane_state *state)
2456{
2457 return state->crtc && state->crtc->state->active;
2458}
2459
2460
2461
2462
2463
2464
2465
2466
2467
2468
2469
2470
2471
2472
2473
2474
2475
2476
2477
2478
2479
2480
2481
2482
2483
2484
2485
2486
2487
2488
2489
2490
2491
2492
2493
2494
2495
2496
2497
2498
2499
2500
2501void drm_atomic_helper_commit_planes(struct drm_device *dev,
2502 struct drm_atomic_state *old_state,
2503 uint32_t flags)
2504{
2505 struct drm_crtc *crtc;
2506 struct drm_crtc_state *old_crtc_state, *new_crtc_state;
2507 struct drm_plane *plane;
2508 struct drm_plane_state *old_plane_state, *new_plane_state;
2509 int i;
2510 bool active_only = flags & DRM_PLANE_COMMIT_ACTIVE_ONLY;
2511 bool no_disable = flags & DRM_PLANE_COMMIT_NO_DISABLE_AFTER_MODESET;
2512
2513 for_each_oldnew_crtc_in_state(old_state, crtc, old_crtc_state, new_crtc_state, i) {
2514 const struct drm_crtc_helper_funcs *funcs;
2515
2516 funcs = crtc->helper_private;
2517
2518 if (!funcs || !funcs->atomic_begin)
2519 continue;
2520
2521 if (active_only && !new_crtc_state->active)
2522 continue;
2523
2524 funcs->atomic_begin(crtc, old_state);
2525 }
2526
2527 for_each_oldnew_plane_in_state(old_state, plane, old_plane_state, new_plane_state, i) {
2528 const struct drm_plane_helper_funcs *funcs;
2529 bool disabling;
2530
2531 funcs = plane->helper_private;
2532
2533 if (!funcs)
2534 continue;
2535
2536 disabling = drm_atomic_plane_disabling(old_plane_state,
2537 new_plane_state);
2538
2539 if (active_only) {
2540
2541
2542
2543
2544
2545
2546
2547 if (!disabling && !plane_crtc_active(new_plane_state))
2548 continue;
2549 if (disabling && !plane_crtc_active(old_plane_state))
2550 continue;
2551 }
2552
2553
2554
2555
2556 if (disabling && funcs->atomic_disable) {
2557 struct drm_crtc_state *crtc_state;
2558
2559 crtc_state = old_plane_state->crtc->state;
2560
2561 if (drm_atomic_crtc_needs_modeset(crtc_state) &&
2562 no_disable)
2563 continue;
2564
2565 funcs->atomic_disable(plane, old_plane_state);
2566 } else if (new_plane_state->crtc || disabling) {
2567 funcs->atomic_update(plane, old_plane_state);
2568 }
2569 }
2570
2571 for_each_oldnew_crtc_in_state(old_state, crtc, old_crtc_state, new_crtc_state, i) {
2572 const struct drm_crtc_helper_funcs *funcs;
2573
2574 funcs = crtc->helper_private;
2575
2576 if (!funcs || !funcs->atomic_flush)
2577 continue;
2578
2579 if (active_only && !new_crtc_state->active)
2580 continue;
2581
2582 funcs->atomic_flush(crtc, old_state);
2583 }
2584}
2585EXPORT_SYMBOL(drm_atomic_helper_commit_planes);
2586
2587
2588
2589
2590
2591
2592
2593
2594
2595
2596
2597
2598
2599
2600
2601
2602
2603
2604void
2605drm_atomic_helper_commit_planes_on_crtc(struct drm_crtc_state *old_crtc_state)
2606{
2607 const struct drm_crtc_helper_funcs *crtc_funcs;
2608 struct drm_crtc *crtc = old_crtc_state->crtc;
2609 struct drm_atomic_state *old_state = old_crtc_state->state;
2610 struct drm_crtc_state *new_crtc_state =
2611 drm_atomic_get_new_crtc_state(old_state, crtc);
2612 struct drm_plane *plane;
2613 unsigned plane_mask;
2614
2615 plane_mask = old_crtc_state->plane_mask;
2616 plane_mask |= new_crtc_state->plane_mask;
2617
2618 crtc_funcs = crtc->helper_private;
2619 if (crtc_funcs && crtc_funcs->atomic_begin)
2620 crtc_funcs->atomic_begin(crtc, old_state);
2621
2622 drm_for_each_plane_mask(plane, crtc->dev, plane_mask) {
2623 struct drm_plane_state *old_plane_state =
2624 drm_atomic_get_old_plane_state(old_state, plane);
2625 struct drm_plane_state *new_plane_state =
2626 drm_atomic_get_new_plane_state(old_state, plane);
2627 const struct drm_plane_helper_funcs *plane_funcs;
2628
2629 plane_funcs = plane->helper_private;
2630
2631 if (!old_plane_state || !plane_funcs)
2632 continue;
2633
2634 WARN_ON(new_plane_state->crtc &&
2635 new_plane_state->crtc != crtc);
2636
2637 if (drm_atomic_plane_disabling(old_plane_state, new_plane_state) &&
2638 plane_funcs->atomic_disable)
2639 plane_funcs->atomic_disable(plane, old_plane_state);
2640 else if (new_plane_state->crtc ||
2641 drm_atomic_plane_disabling(old_plane_state, new_plane_state))
2642 plane_funcs->atomic_update(plane, old_plane_state);
2643 }
2644
2645 if (crtc_funcs && crtc_funcs->atomic_flush)
2646 crtc_funcs->atomic_flush(crtc, old_state);
2647}
2648EXPORT_SYMBOL(drm_atomic_helper_commit_planes_on_crtc);
2649
2650
2651
2652
2653
2654
2655
2656
2657
2658
2659
2660
2661
2662
2663
2664
2665
2666void
2667drm_atomic_helper_disable_planes_on_crtc(struct drm_crtc_state *old_crtc_state,
2668 bool atomic)
2669{
2670 struct drm_crtc *crtc = old_crtc_state->crtc;
2671 const struct drm_crtc_helper_funcs *crtc_funcs =
2672 crtc->helper_private;
2673 struct drm_plane *plane;
2674
2675 if (atomic && crtc_funcs && crtc_funcs->atomic_begin)
2676 crtc_funcs->atomic_begin(crtc, NULL);
2677
2678 drm_atomic_crtc_state_for_each_plane(plane, old_crtc_state) {
2679 const struct drm_plane_helper_funcs *plane_funcs =
2680 plane->helper_private;
2681
2682 if (!plane_funcs)
2683 continue;
2684
2685 WARN_ON(!plane_funcs->atomic_disable);
2686 if (plane_funcs->atomic_disable)
2687 plane_funcs->atomic_disable(plane, NULL);
2688 }
2689
2690 if (atomic && crtc_funcs && crtc_funcs->atomic_flush)
2691 crtc_funcs->atomic_flush(crtc, NULL);
2692}
2693EXPORT_SYMBOL(drm_atomic_helper_disable_planes_on_crtc);
2694
2695
2696
2697
2698
2699
2700
2701
2702
2703
2704
2705
2706
2707void drm_atomic_helper_cleanup_planes(struct drm_device *dev,
2708 struct drm_atomic_state *old_state)
2709{
2710 struct drm_plane *plane;
2711 struct drm_plane_state *old_plane_state, *new_plane_state;
2712 int i;
2713
2714 for_each_oldnew_plane_in_state(old_state, plane, old_plane_state, new_plane_state, i) {
2715 const struct drm_plane_helper_funcs *funcs;
2716 struct drm_plane_state *plane_state;
2717
2718
2719
2720
2721
2722 if (old_plane_state == plane->state)
2723 plane_state = new_plane_state;
2724 else
2725 plane_state = old_plane_state;
2726
2727 funcs = plane->helper_private;
2728
2729 if (funcs->cleanup_fb)
2730 funcs->cleanup_fb(plane, plane_state);
2731 }
2732}
2733EXPORT_SYMBOL(drm_atomic_helper_cleanup_planes);
2734
2735
2736
2737
2738
2739
2740
2741
2742
2743
2744
2745
2746
2747
2748
2749
2750
2751
2752
2753
2754
2755
2756
2757
2758
2759
2760
2761
2762
2763
2764
2765
2766
2767
2768
2769
2770int drm_atomic_helper_swap_state(struct drm_atomic_state *state,
2771 bool stall)
2772{
2773 int i, ret;
2774 struct drm_connector *connector;
2775 struct drm_connector_state *old_conn_state, *new_conn_state;
2776 struct drm_crtc *crtc;
2777 struct drm_crtc_state *old_crtc_state, *new_crtc_state;
2778 struct drm_plane *plane;
2779 struct drm_plane_state *old_plane_state, *new_plane_state;
2780 struct drm_crtc_commit *commit;
2781 struct drm_private_obj *obj;
2782 struct drm_private_state *old_obj_state, *new_obj_state;
2783
2784 if (stall) {
2785
2786
2787
2788
2789
2790
2791
2792
2793
2794 for_each_old_crtc_in_state(state, crtc, old_crtc_state, i) {
2795 commit = old_crtc_state->commit;
2796
2797 if (!commit)
2798 continue;
2799
2800 ret = wait_for_completion_interruptible(&commit->hw_done);
2801 if (ret)
2802 return ret;
2803 }
2804
2805 for_each_old_connector_in_state(state, connector, old_conn_state, i) {
2806 commit = old_conn_state->commit;
2807
2808 if (!commit)
2809 continue;
2810
2811 ret = wait_for_completion_interruptible(&commit->hw_done);
2812 if (ret)
2813 return ret;
2814 }
2815
2816 for_each_old_plane_in_state(state, plane, old_plane_state, i) {
2817 commit = old_plane_state->commit;
2818
2819 if (!commit)
2820 continue;
2821
2822 ret = wait_for_completion_interruptible(&commit->hw_done);
2823 if (ret)
2824 return ret;
2825 }
2826 }
2827
2828 for_each_oldnew_connector_in_state(state, connector, old_conn_state, new_conn_state, i) {
2829 WARN_ON(connector->state != old_conn_state);
2830
2831 old_conn_state->state = state;
2832 new_conn_state->state = NULL;
2833
2834 state->connectors[i].state = old_conn_state;
2835 connector->state = new_conn_state;
2836 }
2837
2838 for_each_oldnew_crtc_in_state(state, crtc, old_crtc_state, new_crtc_state, i) {
2839 WARN_ON(crtc->state != old_crtc_state);
2840
2841 old_crtc_state->state = state;
2842 new_crtc_state->state = NULL;
2843
2844 state->crtcs[i].state = old_crtc_state;
2845 crtc->state = new_crtc_state;
2846
2847 if (new_crtc_state->commit) {
2848 spin_lock(&crtc->commit_lock);
2849 list_add(&new_crtc_state->commit->commit_entry,
2850 &crtc->commit_list);
2851 spin_unlock(&crtc->commit_lock);
2852
2853 new_crtc_state->commit->event = NULL;
2854 }
2855 }
2856
2857 for_each_oldnew_plane_in_state(state, plane, old_plane_state, new_plane_state, i) {
2858 WARN_ON(plane->state != old_plane_state);
2859
2860 old_plane_state->state = state;
2861 new_plane_state->state = NULL;
2862
2863 state->planes[i].state = old_plane_state;
2864 plane->state = new_plane_state;
2865 }
2866
2867 for_each_oldnew_private_obj_in_state(state, obj, old_obj_state, new_obj_state, i) {
2868 WARN_ON(obj->state != old_obj_state);
2869
2870 old_obj_state->state = state;
2871 new_obj_state->state = NULL;
2872
2873 state->private_objs[i].state = old_obj_state;
2874 obj->state = new_obj_state;
2875 }
2876
2877 return 0;
2878}
2879EXPORT_SYMBOL(drm_atomic_helper_swap_state);
2880
2881
2882
2883
2884
2885
2886
2887
2888
2889
2890
2891
2892
2893
2894
2895
2896
2897
2898
2899
2900
2901int drm_atomic_helper_update_plane(struct drm_plane *plane,
2902 struct drm_crtc *crtc,
2903 struct drm_framebuffer *fb,
2904 int crtc_x, int crtc_y,
2905 unsigned int crtc_w, unsigned int crtc_h,
2906 uint32_t src_x, uint32_t src_y,
2907 uint32_t src_w, uint32_t src_h,
2908 struct drm_modeset_acquire_ctx *ctx)
2909{
2910 struct drm_atomic_state *state;
2911 struct drm_plane_state *plane_state;
2912 int ret = 0;
2913
2914 state = drm_atomic_state_alloc(plane->dev);
2915 if (!state)
2916 return -ENOMEM;
2917
2918 state->acquire_ctx = ctx;
2919 plane_state = drm_atomic_get_plane_state(state, plane);
2920 if (IS_ERR(plane_state)) {
2921 ret = PTR_ERR(plane_state);
2922 goto fail;
2923 }
2924
2925 ret = drm_atomic_set_crtc_for_plane(plane_state, crtc);
2926 if (ret != 0)
2927 goto fail;
2928 drm_atomic_set_fb_for_plane(plane_state, fb);
2929 plane_state->crtc_x = crtc_x;
2930 plane_state->crtc_y = crtc_y;
2931 plane_state->crtc_w = crtc_w;
2932 plane_state->crtc_h = crtc_h;
2933 plane_state->src_x = src_x;
2934 plane_state->src_y = src_y;
2935 plane_state->src_w = src_w;
2936 plane_state->src_h = src_h;
2937
2938 if (plane == crtc->cursor)
2939 state->legacy_cursor_update = true;
2940
2941 ret = drm_atomic_commit(state);
2942fail:
2943 drm_atomic_state_put(state);
2944 return ret;
2945}
2946EXPORT_SYMBOL(drm_atomic_helper_update_plane);
2947
2948
2949
2950
2951
2952
2953
2954
2955
2956
2957
2958int drm_atomic_helper_disable_plane(struct drm_plane *plane,
2959 struct drm_modeset_acquire_ctx *ctx)
2960{
2961 struct drm_atomic_state *state;
2962 struct drm_plane_state *plane_state;
2963 int ret = 0;
2964
2965 state = drm_atomic_state_alloc(plane->dev);
2966 if (!state)
2967 return -ENOMEM;
2968
2969 state->acquire_ctx = ctx;
2970 plane_state = drm_atomic_get_plane_state(state, plane);
2971 if (IS_ERR(plane_state)) {
2972 ret = PTR_ERR(plane_state);
2973 goto fail;
2974 }
2975
2976 if (plane_state->crtc && plane_state->crtc->cursor == plane)
2977 plane_state->state->legacy_cursor_update = true;
2978
2979 ret = __drm_atomic_helper_disable_plane(plane, plane_state);
2980 if (ret != 0)
2981 goto fail;
2982
2983 ret = drm_atomic_commit(state);
2984fail:
2985 drm_atomic_state_put(state);
2986 return ret;
2987}
2988EXPORT_SYMBOL(drm_atomic_helper_disable_plane);
2989
2990
2991
2992
2993
2994
2995
2996
2997
2998
2999
3000
3001
3002
3003
3004
3005
3006int drm_atomic_helper_set_config(struct drm_mode_set *set,
3007 struct drm_modeset_acquire_ctx *ctx)
3008{
3009 struct drm_atomic_state *state;
3010 struct drm_crtc *crtc = set->crtc;
3011 int ret = 0;
3012
3013 state = drm_atomic_state_alloc(crtc->dev);
3014 if (!state)
3015 return -ENOMEM;
3016
3017 state->acquire_ctx = ctx;
3018 ret = __drm_atomic_helper_set_config(set, state);
3019 if (ret != 0)
3020 goto fail;
3021
3022 ret = handle_conflicting_encoders(state, true);
3023 if (ret)
3024 goto fail;
3025
3026 ret = drm_atomic_commit(state);
3027
3028fail:
3029 drm_atomic_state_put(state);
3030 return ret;
3031}
3032EXPORT_SYMBOL(drm_atomic_helper_set_config);
3033
3034
3035
3036
3037
3038
3039
3040
3041
3042
3043
3044
3045
3046
3047
3048
3049
3050
3051
3052
3053
3054
3055
3056
3057int drm_atomic_helper_disable_all(struct drm_device *dev,
3058 struct drm_modeset_acquire_ctx *ctx)
3059{
3060 struct drm_atomic_state *state;
3061 struct drm_connector_state *conn_state;
3062 struct drm_connector *conn;
3063 struct drm_plane_state *plane_state;
3064 struct drm_plane *plane;
3065 struct drm_crtc_state *crtc_state;
3066 struct drm_crtc *crtc;
3067 int ret, i;
3068
3069 state = drm_atomic_state_alloc(dev);
3070 if (!state)
3071 return -ENOMEM;
3072
3073 state->acquire_ctx = ctx;
3074
3075 drm_for_each_crtc(crtc, dev) {
3076 crtc_state = drm_atomic_get_crtc_state(state, crtc);
3077 if (IS_ERR(crtc_state)) {
3078 ret = PTR_ERR(crtc_state);
3079 goto free;
3080 }
3081
3082 crtc_state->active = false;
3083
3084 ret = drm_atomic_set_mode_prop_for_crtc(crtc_state, NULL);
3085 if (ret < 0)
3086 goto free;
3087
3088 ret = drm_atomic_add_affected_planes(state, crtc);
3089 if (ret < 0)
3090 goto free;
3091
3092 ret = drm_atomic_add_affected_connectors(state, crtc);
3093 if (ret < 0)
3094 goto free;
3095 }
3096
3097 for_each_new_connector_in_state(state, conn, conn_state, i) {
3098 ret = drm_atomic_set_crtc_for_connector(conn_state, NULL);
3099 if (ret < 0)
3100 goto free;
3101 }
3102
3103 for_each_new_plane_in_state(state, plane, plane_state, i) {
3104 ret = drm_atomic_set_crtc_for_plane(plane_state, NULL);
3105 if (ret < 0)
3106 goto free;
3107
3108 drm_atomic_set_fb_for_plane(plane_state, NULL);
3109 }
3110
3111 ret = drm_atomic_commit(state);
3112free:
3113 drm_atomic_state_put(state);
3114 return ret;
3115}
3116EXPORT_SYMBOL(drm_atomic_helper_disable_all);
3117
3118
3119
3120
3121
3122
3123
3124
3125
3126
3127
3128
3129void drm_atomic_helper_shutdown(struct drm_device *dev)
3130{
3131 struct drm_modeset_acquire_ctx ctx;
3132 int ret;
3133
3134 DRM_MODESET_LOCK_ALL_BEGIN(dev, ctx, 0, ret);
3135
3136 ret = drm_atomic_helper_disable_all(dev, &ctx);
3137 if (ret)
3138 DRM_ERROR("Disabling all crtc's during unload failed with %i\n", ret);
3139
3140 DRM_MODESET_LOCK_ALL_END(dev, ctx, ret);
3141}
3142EXPORT_SYMBOL(drm_atomic_helper_shutdown);
3143
3144
3145
3146
3147
3148
3149
3150
3151
3152
3153
3154
3155
3156
3157
3158
3159
3160
3161
3162
3163
3164
3165
3166
3167
3168struct drm_atomic_state *
3169drm_atomic_helper_duplicate_state(struct drm_device *dev,
3170 struct drm_modeset_acquire_ctx *ctx)
3171{
3172 struct drm_atomic_state *state;
3173 struct drm_connector *conn;
3174 struct drm_connector_list_iter conn_iter;
3175 struct drm_plane *plane;
3176 struct drm_crtc *crtc;
3177 int err = 0;
3178
3179 state = drm_atomic_state_alloc(dev);
3180 if (!state)
3181 return ERR_PTR(-ENOMEM);
3182
3183 state->acquire_ctx = ctx;
3184 state->duplicated = true;
3185
3186 drm_for_each_crtc(crtc, dev) {
3187 struct drm_crtc_state *crtc_state;
3188
3189 crtc_state = drm_atomic_get_crtc_state(state, crtc);
3190 if (IS_ERR(crtc_state)) {
3191 err = PTR_ERR(crtc_state);
3192 goto free;
3193 }
3194 }
3195
3196 drm_for_each_plane(plane, dev) {
3197 struct drm_plane_state *plane_state;
3198
3199 plane_state = drm_atomic_get_plane_state(state, plane);
3200 if (IS_ERR(plane_state)) {
3201 err = PTR_ERR(plane_state);
3202 goto free;
3203 }
3204 }
3205
3206 drm_connector_list_iter_begin(dev, &conn_iter);
3207 drm_for_each_connector_iter(conn, &conn_iter) {
3208 struct drm_connector_state *conn_state;
3209
3210 conn_state = drm_atomic_get_connector_state(state, conn);
3211 if (IS_ERR(conn_state)) {
3212 err = PTR_ERR(conn_state);
3213 drm_connector_list_iter_end(&conn_iter);
3214 goto free;
3215 }
3216 }
3217 drm_connector_list_iter_end(&conn_iter);
3218
3219
3220 state->acquire_ctx = NULL;
3221
3222free:
3223 if (err < 0) {
3224 drm_atomic_state_put(state);
3225 state = ERR_PTR(err);
3226 }
3227
3228 return state;
3229}
3230EXPORT_SYMBOL(drm_atomic_helper_duplicate_state);
3231
3232
3233
3234
3235
3236
3237
3238
3239
3240
3241
3242
3243
3244
3245
3246
3247
3248
3249
3250
3251
3252
3253
3254
3255
3256
3257struct drm_atomic_state *drm_atomic_helper_suspend(struct drm_device *dev)
3258{
3259 struct drm_modeset_acquire_ctx ctx;
3260 struct drm_atomic_state *state;
3261 int err;
3262
3263
3264 state = ERR_PTR(-EINVAL);
3265
3266 DRM_MODESET_LOCK_ALL_BEGIN(dev, ctx, 0, err);
3267
3268 state = drm_atomic_helper_duplicate_state(dev, &ctx);
3269 if (IS_ERR(state))
3270 goto unlock;
3271
3272 err = drm_atomic_helper_disable_all(dev, &ctx);
3273 if (err < 0) {
3274 drm_atomic_state_put(state);
3275 state = ERR_PTR(err);
3276 goto unlock;
3277 }
3278
3279unlock:
3280 DRM_MODESET_LOCK_ALL_END(dev, ctx, err);
3281 if (err)
3282 return ERR_PTR(err);
3283
3284 return state;
3285}
3286EXPORT_SYMBOL(drm_atomic_helper_suspend);
3287
3288
3289
3290
3291
3292
3293
3294
3295
3296
3297
3298
3299
3300
3301
3302
3303int drm_atomic_helper_commit_duplicated_state(struct drm_atomic_state *state,
3304 struct drm_modeset_acquire_ctx *ctx)
3305{
3306 int i, ret;
3307 struct drm_plane *plane;
3308 struct drm_plane_state *new_plane_state;
3309 struct drm_connector *connector;
3310 struct drm_connector_state *new_conn_state;
3311 struct drm_crtc *crtc;
3312 struct drm_crtc_state *new_crtc_state;
3313
3314 state->acquire_ctx = ctx;
3315
3316 for_each_new_plane_in_state(state, plane, new_plane_state, i)
3317 state->planes[i].old_state = plane->state;
3318
3319 for_each_new_crtc_in_state(state, crtc, new_crtc_state, i)
3320 state->crtcs[i].old_state = crtc->state;
3321
3322 for_each_new_connector_in_state(state, connector, new_conn_state, i)
3323 state->connectors[i].old_state = connector->state;
3324
3325 ret = drm_atomic_commit(state);
3326
3327 state->acquire_ctx = NULL;
3328
3329 return ret;
3330}
3331EXPORT_SYMBOL(drm_atomic_helper_commit_duplicated_state);
3332
3333
3334
3335
3336
3337
3338
3339
3340
3341
3342
3343
3344
3345
3346
3347
3348
3349int drm_atomic_helper_resume(struct drm_device *dev,
3350 struct drm_atomic_state *state)
3351{
3352 struct drm_modeset_acquire_ctx ctx;
3353 int err;
3354
3355 drm_mode_config_reset(dev);
3356
3357 DRM_MODESET_LOCK_ALL_BEGIN(dev, ctx, 0, err);
3358
3359 err = drm_atomic_helper_commit_duplicated_state(state, &ctx);
3360
3361 DRM_MODESET_LOCK_ALL_END(dev, ctx, err);
3362 drm_atomic_state_put(state);
3363
3364 return err;
3365}
3366EXPORT_SYMBOL(drm_atomic_helper_resume);
3367
3368static int page_flip_common(struct drm_atomic_state *state,
3369 struct drm_crtc *crtc,
3370 struct drm_framebuffer *fb,
3371 struct drm_pending_vblank_event *event,
3372 uint32_t flags)
3373{
3374 struct drm_plane *plane = crtc->primary;
3375 struct drm_plane_state *plane_state;
3376 struct drm_crtc_state *crtc_state;
3377 int ret = 0;
3378
3379 crtc_state = drm_atomic_get_crtc_state(state, crtc);
3380 if (IS_ERR(crtc_state))
3381 return PTR_ERR(crtc_state);
3382
3383 crtc_state->event = event;
3384 crtc_state->async_flip = flags & DRM_MODE_PAGE_FLIP_ASYNC;
3385
3386 plane_state = drm_atomic_get_plane_state(state, plane);
3387 if (IS_ERR(plane_state))
3388 return PTR_ERR(plane_state);
3389
3390 ret = drm_atomic_set_crtc_for_plane(plane_state, crtc);
3391 if (ret != 0)
3392 return ret;
3393 drm_atomic_set_fb_for_plane(plane_state, fb);
3394
3395
3396 state->allow_modeset = false;
3397 if (!crtc_state->active) {
3398 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] disabled, rejecting legacy flip\n",
3399 crtc->base.id, crtc->name);
3400 return -EINVAL;
3401 }
3402
3403 return ret;
3404}
3405
3406
3407
3408
3409
3410
3411
3412
3413
3414
3415
3416
3417
3418
3419
3420
3421
3422
3423int drm_atomic_helper_page_flip(struct drm_crtc *crtc,
3424 struct drm_framebuffer *fb,
3425 struct drm_pending_vblank_event *event,
3426 uint32_t flags,
3427 struct drm_modeset_acquire_ctx *ctx)
3428{
3429 struct drm_plane *plane = crtc->primary;
3430 struct drm_atomic_state *state;
3431 int ret = 0;
3432
3433 state = drm_atomic_state_alloc(plane->dev);
3434 if (!state)
3435 return -ENOMEM;
3436
3437 state->acquire_ctx = ctx;
3438
3439 ret = page_flip_common(state, crtc, fb, event, flags);
3440 if (ret != 0)
3441 goto fail;
3442
3443 ret = drm_atomic_nonblocking_commit(state);
3444fail:
3445 drm_atomic_state_put(state);
3446 return ret;
3447}
3448EXPORT_SYMBOL(drm_atomic_helper_page_flip);
3449
3450
3451
3452
3453
3454
3455
3456
3457
3458
3459
3460
3461
3462
3463
3464
3465
3466int drm_atomic_helper_page_flip_target(struct drm_crtc *crtc,
3467 struct drm_framebuffer *fb,
3468 struct drm_pending_vblank_event *event,
3469 uint32_t flags,
3470 uint32_t target,
3471 struct drm_modeset_acquire_ctx *ctx)
3472{
3473 struct drm_plane *plane = crtc->primary;
3474 struct drm_atomic_state *state;
3475 struct drm_crtc_state *crtc_state;
3476 int ret = 0;
3477
3478 state = drm_atomic_state_alloc(plane->dev);
3479 if (!state)
3480 return -ENOMEM;
3481
3482 state->acquire_ctx = ctx;
3483
3484 ret = page_flip_common(state, crtc, fb, event, flags);
3485 if (ret != 0)
3486 goto fail;
3487
3488 crtc_state = drm_atomic_get_new_crtc_state(state, crtc);
3489 if (WARN_ON(!crtc_state)) {
3490 ret = -EINVAL;
3491 goto fail;
3492 }
3493 crtc_state->target_vblank = target;
3494
3495 ret = drm_atomic_nonblocking_commit(state);
3496fail:
3497 drm_atomic_state_put(state);
3498 return ret;
3499}
3500EXPORT_SYMBOL(drm_atomic_helper_page_flip_target);
3501
3502
3503
3504
3505
3506
3507
3508
3509
3510
3511
3512
3513
3514
3515
3516int drm_atomic_helper_legacy_gamma_set(struct drm_crtc *crtc,
3517 u16 *red, u16 *green, u16 *blue,
3518 uint32_t size,
3519 struct drm_modeset_acquire_ctx *ctx)
3520{
3521 struct drm_device *dev = crtc->dev;
3522 struct drm_atomic_state *state;
3523 struct drm_crtc_state *crtc_state;
3524 struct drm_property_blob *blob = NULL;
3525 struct drm_color_lut *blob_data;
3526 int i, ret = 0;
3527 bool replaced;
3528
3529 state = drm_atomic_state_alloc(crtc->dev);
3530 if (!state)
3531 return -ENOMEM;
3532
3533 blob = drm_property_create_blob(dev,
3534 sizeof(struct drm_color_lut) * size,
3535 NULL);
3536 if (IS_ERR(blob)) {
3537 ret = PTR_ERR(blob);
3538 blob = NULL;
3539 goto fail;
3540 }
3541
3542
3543 blob_data = blob->data;
3544 for (i = 0; i < size; i++) {
3545 blob_data[i].red = red[i];
3546 blob_data[i].green = green[i];
3547 blob_data[i].blue = blue[i];
3548 }
3549
3550 state->acquire_ctx = ctx;
3551 crtc_state = drm_atomic_get_crtc_state(state, crtc);
3552 if (IS_ERR(crtc_state)) {
3553 ret = PTR_ERR(crtc_state);
3554 goto fail;
3555 }
3556
3557
3558 replaced = drm_property_replace_blob(&crtc_state->degamma_lut, NULL);
3559 replaced |= drm_property_replace_blob(&crtc_state->ctm, NULL);
3560 replaced |= drm_property_replace_blob(&crtc_state->gamma_lut, blob);
3561 crtc_state->color_mgmt_changed |= replaced;
3562
3563 ret = drm_atomic_commit(state);
3564
3565fail:
3566 drm_atomic_state_put(state);
3567 drm_property_blob_put(blob);
3568 return ret;
3569}
3570EXPORT_SYMBOL(drm_atomic_helper_legacy_gamma_set);
3571
3572
3573
3574
3575
3576
3577
3578
3579
3580
3581
3582
3583
3584
3585
3586
3587
3588
3589
3590
3591u32 *
3592drm_atomic_helper_bridge_propagate_bus_fmt(struct drm_bridge *bridge,
3593 struct drm_bridge_state *bridge_state,
3594 struct drm_crtc_state *crtc_state,
3595 struct drm_connector_state *conn_state,
3596 u32 output_fmt,
3597 unsigned int *num_input_fmts)
3598{
3599 u32 *input_fmts;
3600
3601 input_fmts = kzalloc(sizeof(*input_fmts), GFP_KERNEL);
3602 if (!input_fmts) {
3603 *num_input_fmts = 0;
3604 return NULL;
3605 }
3606
3607 *num_input_fmts = 1;
3608 input_fmts[0] = output_fmt;
3609 return input_fmts;
3610}
3611EXPORT_SYMBOL(drm_atomic_helper_bridge_propagate_bus_fmt);
3612