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#include <drm/drmP.h>
30#include <drm/drm_atomic.h>
31#include <drm/drm_mode.h>
32#include <drm/drm_plane_helper.h>
33
34#include "drm_crtc_internal.h"
35
36static void crtc_commit_free(struct kref *kref)
37{
38 struct drm_crtc_commit *commit =
39 container_of(kref, struct drm_crtc_commit, ref);
40
41 kfree(commit);
42}
43
44void drm_crtc_commit_put(struct drm_crtc_commit *commit)
45{
46 kref_put(&commit->ref, crtc_commit_free);
47}
48EXPORT_SYMBOL(drm_crtc_commit_put);
49
50
51
52
53
54
55
56
57
58void drm_atomic_state_default_release(struct drm_atomic_state *state)
59{
60 kfree(state->connectors);
61 kfree(state->crtcs);
62 kfree(state->planes);
63}
64EXPORT_SYMBOL(drm_atomic_state_default_release);
65
66
67
68
69
70
71
72
73
74int
75drm_atomic_state_init(struct drm_device *dev, struct drm_atomic_state *state)
76{
77
78
79
80 state->allow_modeset = true;
81
82 state->crtcs = kcalloc(dev->mode_config.num_crtc,
83 sizeof(*state->crtcs), GFP_KERNEL);
84 if (!state->crtcs)
85 goto fail;
86 state->planes = kcalloc(dev->mode_config.num_total_plane,
87 sizeof(*state->planes), GFP_KERNEL);
88 if (!state->planes)
89 goto fail;
90
91 state->dev = dev;
92
93 DRM_DEBUG_ATOMIC("Allocated atomic state %p\n", state);
94
95 return 0;
96fail:
97 drm_atomic_state_default_release(state);
98 return -ENOMEM;
99}
100EXPORT_SYMBOL(drm_atomic_state_init);
101
102
103
104
105
106
107
108struct drm_atomic_state *
109drm_atomic_state_alloc(struct drm_device *dev)
110{
111 struct drm_mode_config *config = &dev->mode_config;
112 struct drm_atomic_state *state;
113
114 if (!config->funcs->atomic_state_alloc) {
115 state = kzalloc(sizeof(*state), GFP_KERNEL);
116 if (!state)
117 return NULL;
118 if (drm_atomic_state_init(dev, state) < 0) {
119 kfree(state);
120 return NULL;
121 }
122 return state;
123 }
124
125 return config->funcs->atomic_state_alloc(dev);
126}
127EXPORT_SYMBOL(drm_atomic_state_alloc);
128
129
130
131
132
133
134
135
136void drm_atomic_state_default_clear(struct drm_atomic_state *state)
137{
138 struct drm_device *dev = state->dev;
139 struct drm_mode_config *config = &dev->mode_config;
140 int i;
141
142 DRM_DEBUG_ATOMIC("Clearing atomic state %p\n", state);
143
144 for (i = 0; i < state->num_connector; i++) {
145 struct drm_connector *connector = state->connectors[i].ptr;
146
147 if (!connector)
148 continue;
149
150 connector->funcs->atomic_destroy_state(connector,
151 state->connectors[i].state);
152 state->connectors[i].ptr = NULL;
153 state->connectors[i].state = NULL;
154 drm_connector_unreference(connector);
155 }
156
157 for (i = 0; i < config->num_crtc; i++) {
158 struct drm_crtc *crtc = state->crtcs[i].ptr;
159
160 if (!crtc)
161 continue;
162
163 crtc->funcs->atomic_destroy_state(crtc,
164 state->crtcs[i].state);
165
166 if (state->crtcs[i].commit) {
167 kfree(state->crtcs[i].commit->event);
168 state->crtcs[i].commit->event = NULL;
169 drm_crtc_commit_put(state->crtcs[i].commit);
170 }
171
172 state->crtcs[i].commit = NULL;
173 state->crtcs[i].ptr = NULL;
174 state->crtcs[i].state = NULL;
175 }
176
177 for (i = 0; i < config->num_total_plane; i++) {
178 struct drm_plane *plane = state->planes[i].ptr;
179
180 if (!plane)
181 continue;
182
183 plane->funcs->atomic_destroy_state(plane,
184 state->planes[i].state);
185 state->planes[i].ptr = NULL;
186 state->planes[i].state = NULL;
187 }
188}
189EXPORT_SYMBOL(drm_atomic_state_default_clear);
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205void drm_atomic_state_clear(struct drm_atomic_state *state)
206{
207 struct drm_device *dev = state->dev;
208 struct drm_mode_config *config = &dev->mode_config;
209
210 if (config->funcs->atomic_state_clear)
211 config->funcs->atomic_state_clear(state);
212 else
213 drm_atomic_state_default_clear(state);
214}
215EXPORT_SYMBOL(drm_atomic_state_clear);
216
217
218
219
220
221
222
223
224void drm_atomic_state_free(struct drm_atomic_state *state)
225{
226 struct drm_device *dev;
227 struct drm_mode_config *config;
228
229 if (!state)
230 return;
231
232 dev = state->dev;
233 config = &dev->mode_config;
234
235 drm_atomic_state_clear(state);
236
237 DRM_DEBUG_ATOMIC("Freeing atomic state %p\n", state);
238
239 if (config->funcs->atomic_state_free) {
240 config->funcs->atomic_state_free(state);
241 } else {
242 drm_atomic_state_default_release(state);
243 kfree(state);
244 }
245}
246EXPORT_SYMBOL(drm_atomic_state_free);
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263struct drm_crtc_state *
264drm_atomic_get_crtc_state(struct drm_atomic_state *state,
265 struct drm_crtc *crtc)
266{
267 int ret, index = drm_crtc_index(crtc);
268 struct drm_crtc_state *crtc_state;
269
270 WARN_ON(!state->acquire_ctx);
271
272 crtc_state = drm_atomic_get_existing_crtc_state(state, crtc);
273 if (crtc_state)
274 return crtc_state;
275
276 ret = drm_modeset_lock(&crtc->mutex, state->acquire_ctx);
277 if (ret)
278 return ERR_PTR(ret);
279
280 crtc_state = crtc->funcs->atomic_duplicate_state(crtc);
281 if (!crtc_state)
282 return ERR_PTR(-ENOMEM);
283
284 state->crtcs[index].state = crtc_state;
285 state->crtcs[index].ptr = crtc;
286 crtc_state->state = state;
287
288 DRM_DEBUG_ATOMIC("Added [CRTC:%d:%s] %p state to %p\n",
289 crtc->base.id, crtc->name, crtc_state, state);
290
291 return crtc_state;
292}
293EXPORT_SYMBOL(drm_atomic_get_crtc_state);
294
295
296
297
298
299
300
301
302
303
304
305
306
307int drm_atomic_set_mode_for_crtc(struct drm_crtc_state *state,
308 struct drm_display_mode *mode)
309{
310 struct drm_mode_modeinfo umode;
311
312
313 if (mode && memcmp(&state->mode, mode, sizeof(*mode)) == 0)
314 return 0;
315
316 drm_property_unreference_blob(state->mode_blob);
317 state->mode_blob = NULL;
318
319 if (mode) {
320 drm_mode_convert_to_umode(&umode, mode);
321 state->mode_blob =
322 drm_property_create_blob(state->crtc->dev,
323 sizeof(umode),
324 &umode);
325 if (IS_ERR(state->mode_blob))
326 return PTR_ERR(state->mode_blob);
327
328 drm_mode_copy(&state->mode, mode);
329 state->enable = true;
330 DRM_DEBUG_ATOMIC("Set [MODE:%s] for CRTC state %p\n",
331 mode->name, state);
332 } else {
333 memset(&state->mode, 0, sizeof(state->mode));
334 state->enable = false;
335 DRM_DEBUG_ATOMIC("Set [NOMODE] for CRTC state %p\n",
336 state);
337 }
338
339 return 0;
340}
341EXPORT_SYMBOL(drm_atomic_set_mode_for_crtc);
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356int drm_atomic_set_mode_prop_for_crtc(struct drm_crtc_state *state,
357 struct drm_property_blob *blob)
358{
359 if (blob == state->mode_blob)
360 return 0;
361
362 drm_property_unreference_blob(state->mode_blob);
363 state->mode_blob = NULL;
364
365 memset(&state->mode, 0, sizeof(state->mode));
366
367 if (blob) {
368 if (blob->length != sizeof(struct drm_mode_modeinfo) ||
369 drm_mode_convert_umode(&state->mode,
370 (const struct drm_mode_modeinfo *)
371 blob->data))
372 return -EINVAL;
373
374 state->mode_blob = drm_property_reference_blob(blob);
375 state->enable = true;
376 DRM_DEBUG_ATOMIC("Set [MODE:%s] for CRTC state %p\n",
377 state->mode.name, state);
378 } else {
379 state->enable = false;
380 DRM_DEBUG_ATOMIC("Set [NOMODE] for CRTC state %p\n",
381 state);
382 }
383
384 return 0;
385}
386EXPORT_SYMBOL(drm_atomic_set_mode_prop_for_crtc);
387
388
389
390
391
392
393
394
395
396
397static void
398drm_atomic_replace_property_blob(struct drm_property_blob **blob,
399 struct drm_property_blob *new_blob,
400 bool *replaced)
401{
402 struct drm_property_blob *old_blob = *blob;
403
404 if (old_blob == new_blob)
405 return;
406
407 drm_property_unreference_blob(old_blob);
408 if (new_blob)
409 drm_property_reference_blob(new_blob);
410 *blob = new_blob;
411 *replaced = true;
412
413 return;
414}
415
416static int
417drm_atomic_replace_property_blob_from_id(struct drm_crtc *crtc,
418 struct drm_property_blob **blob,
419 uint64_t blob_id,
420 ssize_t expected_size,
421 bool *replaced)
422{
423 struct drm_property_blob *new_blob = NULL;
424
425 if (blob_id != 0) {
426 new_blob = drm_property_lookup_blob(crtc->dev, blob_id);
427 if (new_blob == NULL)
428 return -EINVAL;
429
430 if (expected_size > 0 && expected_size != new_blob->length) {
431 drm_property_unreference_blob(new_blob);
432 return -EINVAL;
433 }
434 }
435
436 drm_atomic_replace_property_blob(blob, new_blob, replaced);
437 drm_property_unreference_blob(new_blob);
438
439 return 0;
440}
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458int drm_atomic_crtc_set_property(struct drm_crtc *crtc,
459 struct drm_crtc_state *state, struct drm_property *property,
460 uint64_t val)
461{
462 struct drm_device *dev = crtc->dev;
463 struct drm_mode_config *config = &dev->mode_config;
464 bool replaced = false;
465 int ret;
466
467 if (property == config->prop_active)
468 state->active = val;
469 else if (property == config->prop_mode_id) {
470 struct drm_property_blob *mode =
471 drm_property_lookup_blob(dev, val);
472 ret = drm_atomic_set_mode_prop_for_crtc(state, mode);
473 drm_property_unreference_blob(mode);
474 return ret;
475 } else if (property == config->degamma_lut_property) {
476 ret = drm_atomic_replace_property_blob_from_id(crtc,
477 &state->degamma_lut,
478 val,
479 -1,
480 &replaced);
481 state->color_mgmt_changed |= replaced;
482 return ret;
483 } else if (property == config->ctm_property) {
484 ret = drm_atomic_replace_property_blob_from_id(crtc,
485 &state->ctm,
486 val,
487 sizeof(struct drm_color_ctm),
488 &replaced);
489 state->color_mgmt_changed |= replaced;
490 return ret;
491 } else if (property == config->gamma_lut_property) {
492 ret = drm_atomic_replace_property_blob_from_id(crtc,
493 &state->gamma_lut,
494 val,
495 -1,
496 &replaced);
497 state->color_mgmt_changed |= replaced;
498 return ret;
499 } else if (crtc->funcs->atomic_set_property)
500 return crtc->funcs->atomic_set_property(crtc, state, property, val);
501 else
502 return -EINVAL;
503
504 return 0;
505}
506EXPORT_SYMBOL(drm_atomic_crtc_set_property);
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523static int
524drm_atomic_crtc_get_property(struct drm_crtc *crtc,
525 const struct drm_crtc_state *state,
526 struct drm_property *property, uint64_t *val)
527{
528 struct drm_device *dev = crtc->dev;
529 struct drm_mode_config *config = &dev->mode_config;
530
531 if (property == config->prop_active)
532 *val = state->active;
533 else if (property == config->prop_mode_id)
534 *val = (state->mode_blob) ? state->mode_blob->base.id : 0;
535 else if (property == config->degamma_lut_property)
536 *val = (state->degamma_lut) ? state->degamma_lut->base.id : 0;
537 else if (property == config->ctm_property)
538 *val = (state->ctm) ? state->ctm->base.id : 0;
539 else if (property == config->gamma_lut_property)
540 *val = (state->gamma_lut) ? state->gamma_lut->base.id : 0;
541 else if (crtc->funcs->atomic_get_property)
542 return crtc->funcs->atomic_get_property(crtc, state, property, val);
543 else
544 return -EINVAL;
545
546 return 0;
547}
548
549
550
551
552
553
554
555
556
557
558
559static int drm_atomic_crtc_check(struct drm_crtc *crtc,
560 struct drm_crtc_state *state)
561{
562
563
564
565
566
567
568
569
570 if (state->active && !state->enable) {
571 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] active without enabled\n",
572 crtc->base.id, crtc->name);
573 return -EINVAL;
574 }
575
576
577
578
579 if (drm_core_check_feature(crtc->dev, DRIVER_ATOMIC) &&
580 WARN_ON(state->enable && !state->mode_blob)) {
581 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] enabled without mode blob\n",
582 crtc->base.id, crtc->name);
583 return -EINVAL;
584 }
585
586 if (drm_core_check_feature(crtc->dev, DRIVER_ATOMIC) &&
587 WARN_ON(!state->enable && state->mode_blob)) {
588 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] disabled with mode blob\n",
589 crtc->base.id, crtc->name);
590 return -EINVAL;
591 }
592
593
594
595
596
597
598
599
600
601
602
603 if (state->event && !state->active && !crtc->state->active) {
604 DRM_DEBUG_ATOMIC("[CRTC:%d] requesting event but off\n",
605 crtc->base.id);
606 return -EINVAL;
607 }
608
609 return 0;
610}
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627struct drm_plane_state *
628drm_atomic_get_plane_state(struct drm_atomic_state *state,
629 struct drm_plane *plane)
630{
631 int ret, index = drm_plane_index(plane);
632 struct drm_plane_state *plane_state;
633
634 WARN_ON(!state->acquire_ctx);
635
636 plane_state = drm_atomic_get_existing_plane_state(state, plane);
637 if (plane_state)
638 return plane_state;
639
640 ret = drm_modeset_lock(&plane->mutex, state->acquire_ctx);
641 if (ret)
642 return ERR_PTR(ret);
643
644 plane_state = plane->funcs->atomic_duplicate_state(plane);
645 if (!plane_state)
646 return ERR_PTR(-ENOMEM);
647
648 state->planes[index].state = plane_state;
649 state->planes[index].ptr = plane;
650 plane_state->state = state;
651
652 DRM_DEBUG_ATOMIC("Added [PLANE:%d:%s] %p state to %p\n",
653 plane->base.id, plane->name, plane_state, state);
654
655 if (plane_state->crtc) {
656 struct drm_crtc_state *crtc_state;
657
658 crtc_state = drm_atomic_get_crtc_state(state,
659 plane_state->crtc);
660 if (IS_ERR(crtc_state))
661 return ERR_CAST(crtc_state);
662 }
663
664 return plane_state;
665}
666EXPORT_SYMBOL(drm_atomic_get_plane_state);
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684int drm_atomic_plane_set_property(struct drm_plane *plane,
685 struct drm_plane_state *state, struct drm_property *property,
686 uint64_t val)
687{
688 struct drm_device *dev = plane->dev;
689 struct drm_mode_config *config = &dev->mode_config;
690
691 if (property == config->prop_fb_id) {
692 struct drm_framebuffer *fb = drm_framebuffer_lookup(dev, val);
693 drm_atomic_set_fb_for_plane(state, fb);
694 if (fb)
695 drm_framebuffer_unreference(fb);
696 } else if (property == config->prop_crtc_id) {
697 struct drm_crtc *crtc = drm_crtc_find(dev, val);
698 return drm_atomic_set_crtc_for_plane(state, crtc);
699 } else if (property == config->prop_crtc_x) {
700 state->crtc_x = U642I64(val);
701 } else if (property == config->prop_crtc_y) {
702 state->crtc_y = U642I64(val);
703 } else if (property == config->prop_crtc_w) {
704 state->crtc_w = val;
705 } else if (property == config->prop_crtc_h) {
706 state->crtc_h = val;
707 } else if (property == config->prop_src_x) {
708 state->src_x = val;
709 } else if (property == config->prop_src_y) {
710 state->src_y = val;
711 } else if (property == config->prop_src_w) {
712 state->src_w = val;
713 } else if (property == config->prop_src_h) {
714 state->src_h = val;
715 } else if (property == config->rotation_property) {
716 state->rotation = val;
717 } else if (property == plane->zpos_property) {
718 state->zpos = val;
719 } else if (plane->funcs->atomic_set_property) {
720 return plane->funcs->atomic_set_property(plane, state,
721 property, val);
722 } else {
723 return -EINVAL;
724 }
725
726 return 0;
727}
728EXPORT_SYMBOL(drm_atomic_plane_set_property);
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745static int
746drm_atomic_plane_get_property(struct drm_plane *plane,
747 const struct drm_plane_state *state,
748 struct drm_property *property, uint64_t *val)
749{
750 struct drm_device *dev = plane->dev;
751 struct drm_mode_config *config = &dev->mode_config;
752
753 if (property == config->prop_fb_id) {
754 *val = (state->fb) ? state->fb->base.id : 0;
755 } else if (property == config->prop_crtc_id) {
756 *val = (state->crtc) ? state->crtc->base.id : 0;
757 } else if (property == config->prop_crtc_x) {
758 *val = I642U64(state->crtc_x);
759 } else if (property == config->prop_crtc_y) {
760 *val = I642U64(state->crtc_y);
761 } else if (property == config->prop_crtc_w) {
762 *val = state->crtc_w;
763 } else if (property == config->prop_crtc_h) {
764 *val = state->crtc_h;
765 } else if (property == config->prop_src_x) {
766 *val = state->src_x;
767 } else if (property == config->prop_src_y) {
768 *val = state->src_y;
769 } else if (property == config->prop_src_w) {
770 *val = state->src_w;
771 } else if (property == config->prop_src_h) {
772 *val = state->src_h;
773 } else if (property == config->rotation_property) {
774 *val = state->rotation;
775 } else if (property == plane->zpos_property) {
776 *val = state->zpos;
777 } else if (plane->funcs->atomic_get_property) {
778 return plane->funcs->atomic_get_property(plane, state, property, val);
779 } else {
780 return -EINVAL;
781 }
782
783 return 0;
784}
785
786static bool
787plane_switching_crtc(struct drm_atomic_state *state,
788 struct drm_plane *plane,
789 struct drm_plane_state *plane_state)
790{
791 if (!plane->state->crtc || !plane_state->crtc)
792 return false;
793
794 if (plane->state->crtc == plane_state->crtc)
795 return false;
796
797
798
799
800
801
802 return true;
803}
804
805
806
807
808
809
810
811
812
813
814
815static int drm_atomic_plane_check(struct drm_plane *plane,
816 struct drm_plane_state *state)
817{
818 unsigned int fb_width, fb_height;
819 int ret;
820
821
822 if (WARN_ON(state->crtc && !state->fb)) {
823 DRM_DEBUG_ATOMIC("CRTC set but no FB\n");
824 return -EINVAL;
825 } else if (WARN_ON(state->fb && !state->crtc)) {
826 DRM_DEBUG_ATOMIC("FB set but no CRTC\n");
827 return -EINVAL;
828 }
829
830
831 if (!state->crtc)
832 return 0;
833
834
835 if (!(plane->possible_crtcs & drm_crtc_mask(state->crtc))) {
836 DRM_DEBUG_ATOMIC("Invalid crtc for plane\n");
837 return -EINVAL;
838 }
839
840
841 ret = drm_plane_check_pixel_format(plane, state->fb->pixel_format);
842 if (ret) {
843 char *format_name = drm_get_format_name(state->fb->pixel_format);
844 DRM_DEBUG_ATOMIC("Invalid pixel format %s\n", format_name);
845 kfree(format_name);
846 return ret;
847 }
848
849
850 if (state->crtc_w > INT_MAX ||
851 state->crtc_x > INT_MAX - (int32_t) state->crtc_w ||
852 state->crtc_h > INT_MAX ||
853 state->crtc_y > INT_MAX - (int32_t) state->crtc_h) {
854 DRM_DEBUG_ATOMIC("Invalid CRTC coordinates %ux%u+%d+%d\n",
855 state->crtc_w, state->crtc_h,
856 state->crtc_x, state->crtc_y);
857 return -ERANGE;
858 }
859
860 fb_width = state->fb->width << 16;
861 fb_height = state->fb->height << 16;
862
863
864 if (state->src_w > fb_width ||
865 state->src_x > fb_width - state->src_w ||
866 state->src_h > fb_height ||
867 state->src_y > fb_height - state->src_h) {
868 DRM_DEBUG_ATOMIC("Invalid source coordinates "
869 "%u.%06ux%u.%06u+%u.%06u+%u.%06u\n",
870 state->src_w >> 16, ((state->src_w & 0xffff) * 15625) >> 10,
871 state->src_h >> 16, ((state->src_h & 0xffff) * 15625) >> 10,
872 state->src_x >> 16, ((state->src_x & 0xffff) * 15625) >> 10,
873 state->src_y >> 16, ((state->src_y & 0xffff) * 15625) >> 10);
874 return -ENOSPC;
875 }
876
877 if (plane_switching_crtc(state->state, plane, state)) {
878 DRM_DEBUG_ATOMIC("[PLANE:%d:%s] switching CRTC directly\n",
879 plane->base.id, plane->name);
880 return -EINVAL;
881 }
882
883 return 0;
884}
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901struct drm_connector_state *
902drm_atomic_get_connector_state(struct drm_atomic_state *state,
903 struct drm_connector *connector)
904{
905 int ret, index;
906 struct drm_mode_config *config = &connector->dev->mode_config;
907 struct drm_connector_state *connector_state;
908
909 WARN_ON(!state->acquire_ctx);
910
911 ret = drm_modeset_lock(&config->connection_mutex, state->acquire_ctx);
912 if (ret)
913 return ERR_PTR(ret);
914
915 index = drm_connector_index(connector);
916
917 if (index >= state->num_connector) {
918 struct __drm_connnectors_state *c;
919 int alloc = max(index + 1, config->num_connector);
920
921 c = krealloc(state->connectors, alloc * sizeof(*state->connectors), GFP_KERNEL);
922 if (!c)
923 return ERR_PTR(-ENOMEM);
924
925 state->connectors = c;
926 memset(&state->connectors[state->num_connector], 0,
927 sizeof(*state->connectors) * (alloc - state->num_connector));
928
929 state->num_connector = alloc;
930 }
931
932 if (state->connectors[index].state)
933 return state->connectors[index].state;
934
935 connector_state = connector->funcs->atomic_duplicate_state(connector);
936 if (!connector_state)
937 return ERR_PTR(-ENOMEM);
938
939 drm_connector_reference(connector);
940 state->connectors[index].state = connector_state;
941 state->connectors[index].ptr = connector;
942 connector_state->state = state;
943
944 DRM_DEBUG_ATOMIC("Added [CONNECTOR:%d] %p state to %p\n",
945 connector->base.id, connector_state, state);
946
947 if (connector_state->crtc) {
948 struct drm_crtc_state *crtc_state;
949
950 crtc_state = drm_atomic_get_crtc_state(state,
951 connector_state->crtc);
952 if (IS_ERR(crtc_state))
953 return ERR_CAST(crtc_state);
954 }
955
956 return connector_state;
957}
958EXPORT_SYMBOL(drm_atomic_get_connector_state);
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976int drm_atomic_connector_set_property(struct drm_connector *connector,
977 struct drm_connector_state *state, struct drm_property *property,
978 uint64_t val)
979{
980 struct drm_device *dev = connector->dev;
981 struct drm_mode_config *config = &dev->mode_config;
982
983 if (property == config->prop_crtc_id) {
984 struct drm_crtc *crtc = drm_crtc_find(dev, val);
985 return drm_atomic_set_crtc_for_connector(state, crtc);
986 } else if (property == config->dpms_property) {
987
988
989
990
991 return -EINVAL;
992 } else if (connector->funcs->atomic_set_property) {
993 return connector->funcs->atomic_set_property(connector,
994 state, property, val);
995 } else {
996 return -EINVAL;
997 }
998}
999EXPORT_SYMBOL(drm_atomic_connector_set_property);
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016static int
1017drm_atomic_connector_get_property(struct drm_connector *connector,
1018 const struct drm_connector_state *state,
1019 struct drm_property *property, uint64_t *val)
1020{
1021 struct drm_device *dev = connector->dev;
1022 struct drm_mode_config *config = &dev->mode_config;
1023
1024 if (property == config->prop_crtc_id) {
1025 *val = (state->crtc) ? state->crtc->base.id : 0;
1026 } else if (property == config->dpms_property) {
1027 *val = connector->dpms;
1028 } else if (connector->funcs->atomic_get_property) {
1029 return connector->funcs->atomic_get_property(connector,
1030 state, property, val);
1031 } else {
1032 return -EINVAL;
1033 }
1034
1035 return 0;
1036}
1037
1038int drm_atomic_get_property(struct drm_mode_object *obj,
1039 struct drm_property *property, uint64_t *val)
1040{
1041 struct drm_device *dev = property->dev;
1042 int ret;
1043
1044 switch (obj->type) {
1045 case DRM_MODE_OBJECT_CONNECTOR: {
1046 struct drm_connector *connector = obj_to_connector(obj);
1047 WARN_ON(!drm_modeset_is_locked(&dev->mode_config.connection_mutex));
1048 ret = drm_atomic_connector_get_property(connector,
1049 connector->state, property, val);
1050 break;
1051 }
1052 case DRM_MODE_OBJECT_CRTC: {
1053 struct drm_crtc *crtc = obj_to_crtc(obj);
1054 WARN_ON(!drm_modeset_is_locked(&crtc->mutex));
1055 ret = drm_atomic_crtc_get_property(crtc,
1056 crtc->state, property, val);
1057 break;
1058 }
1059 case DRM_MODE_OBJECT_PLANE: {
1060 struct drm_plane *plane = obj_to_plane(obj);
1061 WARN_ON(!drm_modeset_is_locked(&plane->mutex));
1062 ret = drm_atomic_plane_get_property(plane,
1063 plane->state, property, val);
1064 break;
1065 }
1066 default:
1067 ret = -EINVAL;
1068 break;
1069 }
1070
1071 return ret;
1072}
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088int
1089drm_atomic_set_crtc_for_plane(struct drm_plane_state *plane_state,
1090 struct drm_crtc *crtc)
1091{
1092 struct drm_plane *plane = plane_state->plane;
1093 struct drm_crtc_state *crtc_state;
1094
1095 if (plane_state->crtc) {
1096 crtc_state = drm_atomic_get_crtc_state(plane_state->state,
1097 plane_state->crtc);
1098 if (WARN_ON(IS_ERR(crtc_state)))
1099 return PTR_ERR(crtc_state);
1100
1101 crtc_state->plane_mask &= ~(1 << drm_plane_index(plane));
1102 }
1103
1104 plane_state->crtc = crtc;
1105
1106 if (crtc) {
1107 crtc_state = drm_atomic_get_crtc_state(plane_state->state,
1108 crtc);
1109 if (IS_ERR(crtc_state))
1110 return PTR_ERR(crtc_state);
1111 crtc_state->plane_mask |= (1 << drm_plane_index(plane));
1112 }
1113
1114 if (crtc)
1115 DRM_DEBUG_ATOMIC("Link plane state %p to [CRTC:%d:%s]\n",
1116 plane_state, crtc->base.id, crtc->name);
1117 else
1118 DRM_DEBUG_ATOMIC("Link plane state %p to [NOCRTC]\n",
1119 plane_state);
1120
1121 return 0;
1122}
1123EXPORT_SYMBOL(drm_atomic_set_crtc_for_plane);
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135void
1136drm_atomic_set_fb_for_plane(struct drm_plane_state *plane_state,
1137 struct drm_framebuffer *fb)
1138{
1139 if (plane_state->fb)
1140 drm_framebuffer_unreference(plane_state->fb);
1141 if (fb)
1142 drm_framebuffer_reference(fb);
1143 plane_state->fb = fb;
1144
1145 if (fb)
1146 DRM_DEBUG_ATOMIC("Set [FB:%d] for plane state %p\n",
1147 fb->base.id, plane_state);
1148 else
1149 DRM_DEBUG_ATOMIC("Set [NOFB] for plane state %p\n",
1150 plane_state);
1151}
1152EXPORT_SYMBOL(drm_atomic_set_fb_for_plane);
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168int
1169drm_atomic_set_crtc_for_connector(struct drm_connector_state *conn_state,
1170 struct drm_crtc *crtc)
1171{
1172 struct drm_crtc_state *crtc_state;
1173
1174 if (conn_state->crtc == crtc)
1175 return 0;
1176
1177 if (conn_state->crtc) {
1178 crtc_state = drm_atomic_get_existing_crtc_state(conn_state->state,
1179 conn_state->crtc);
1180
1181 crtc_state->connector_mask &=
1182 ~(1 << drm_connector_index(conn_state->connector));
1183
1184 drm_connector_unreference(conn_state->connector);
1185 conn_state->crtc = NULL;
1186 }
1187
1188 if (crtc) {
1189 crtc_state = drm_atomic_get_crtc_state(conn_state->state, crtc);
1190 if (IS_ERR(crtc_state))
1191 return PTR_ERR(crtc_state);
1192
1193 crtc_state->connector_mask |=
1194 1 << drm_connector_index(conn_state->connector);
1195
1196 drm_connector_reference(conn_state->connector);
1197 conn_state->crtc = crtc;
1198
1199 DRM_DEBUG_ATOMIC("Link connector state %p to [CRTC:%d:%s]\n",
1200 conn_state, crtc->base.id, crtc->name);
1201 } else {
1202 DRM_DEBUG_ATOMIC("Link connector state %p to [NOCRTC]\n",
1203 conn_state);
1204 }
1205
1206 return 0;
1207}
1208EXPORT_SYMBOL(drm_atomic_set_crtc_for_connector);
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227int
1228drm_atomic_add_affected_connectors(struct drm_atomic_state *state,
1229 struct drm_crtc *crtc)
1230{
1231 struct drm_mode_config *config = &state->dev->mode_config;
1232 struct drm_connector *connector;
1233 struct drm_connector_state *conn_state;
1234 int ret;
1235
1236 ret = drm_modeset_lock(&config->connection_mutex, state->acquire_ctx);
1237 if (ret)
1238 return ret;
1239
1240 DRM_DEBUG_ATOMIC("Adding all current connectors for [CRTC:%d:%s] to %p\n",
1241 crtc->base.id, crtc->name, state);
1242
1243
1244
1245
1246
1247 drm_for_each_connector(connector, state->dev) {
1248 if (connector->state->crtc != crtc)
1249 continue;
1250
1251 conn_state = drm_atomic_get_connector_state(state, connector);
1252 if (IS_ERR(conn_state))
1253 return PTR_ERR(conn_state);
1254 }
1255
1256 return 0;
1257}
1258EXPORT_SYMBOL(drm_atomic_add_affected_connectors);
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280int
1281drm_atomic_add_affected_planes(struct drm_atomic_state *state,
1282 struct drm_crtc *crtc)
1283{
1284 struct drm_plane *plane;
1285
1286 WARN_ON(!drm_atomic_get_existing_crtc_state(state, crtc));
1287
1288 drm_for_each_plane_mask(plane, state->dev, crtc->state->plane_mask) {
1289 struct drm_plane_state *plane_state =
1290 drm_atomic_get_plane_state(state, plane);
1291
1292 if (IS_ERR(plane_state))
1293 return PTR_ERR(plane_state);
1294 }
1295 return 0;
1296}
1297EXPORT_SYMBOL(drm_atomic_add_affected_planes);
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307void drm_atomic_legacy_backoff(struct drm_atomic_state *state)
1308{
1309 struct drm_device *dev = state->dev;
1310 unsigned crtc_mask = 0;
1311 struct drm_crtc *crtc;
1312 int ret;
1313 bool global = false;
1314
1315 drm_for_each_crtc(crtc, dev) {
1316 if (crtc->acquire_ctx != state->acquire_ctx)
1317 continue;
1318
1319 crtc_mask |= drm_crtc_mask(crtc);
1320 crtc->acquire_ctx = NULL;
1321 }
1322
1323 if (WARN_ON(dev->mode_config.acquire_ctx == state->acquire_ctx)) {
1324 global = true;
1325
1326 dev->mode_config.acquire_ctx = NULL;
1327 }
1328
1329retry:
1330 drm_modeset_backoff(state->acquire_ctx);
1331
1332 ret = drm_modeset_lock_all_ctx(dev, state->acquire_ctx);
1333 if (ret)
1334 goto retry;
1335
1336 drm_for_each_crtc(crtc, dev)
1337 if (drm_crtc_mask(crtc) & crtc_mask)
1338 crtc->acquire_ctx = state->acquire_ctx;
1339
1340 if (global)
1341 dev->mode_config.acquire_ctx = state->acquire_ctx;
1342}
1343EXPORT_SYMBOL(drm_atomic_legacy_backoff);
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356int drm_atomic_check_only(struct drm_atomic_state *state)
1357{
1358 struct drm_device *dev = state->dev;
1359 struct drm_mode_config *config = &dev->mode_config;
1360 struct drm_plane *plane;
1361 struct drm_plane_state *plane_state;
1362 struct drm_crtc *crtc;
1363 struct drm_crtc_state *crtc_state;
1364 int i, ret = 0;
1365
1366 DRM_DEBUG_ATOMIC("checking %p\n", state);
1367
1368 for_each_plane_in_state(state, plane, plane_state, i) {
1369 ret = drm_atomic_plane_check(plane, plane_state);
1370 if (ret) {
1371 DRM_DEBUG_ATOMIC("[PLANE:%d:%s] atomic core check failed\n",
1372 plane->base.id, plane->name);
1373 return ret;
1374 }
1375 }
1376
1377 for_each_crtc_in_state(state, crtc, crtc_state, i) {
1378 ret = drm_atomic_crtc_check(crtc, crtc_state);
1379 if (ret) {
1380 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] atomic core check failed\n",
1381 crtc->base.id, crtc->name);
1382 return ret;
1383 }
1384 }
1385
1386 if (config->funcs->atomic_check)
1387 ret = config->funcs->atomic_check(state->dev, state);
1388
1389 if (!state->allow_modeset) {
1390 for_each_crtc_in_state(state, crtc, crtc_state, i) {
1391 if (drm_atomic_crtc_needs_modeset(crtc_state)) {
1392 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] requires full modeset\n",
1393 crtc->base.id, crtc->name);
1394 return -EINVAL;
1395 }
1396 }
1397 }
1398
1399 return ret;
1400}
1401EXPORT_SYMBOL(drm_atomic_check_only);
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419int drm_atomic_commit(struct drm_atomic_state *state)
1420{
1421 struct drm_mode_config *config = &state->dev->mode_config;
1422 int ret;
1423
1424 ret = drm_atomic_check_only(state);
1425 if (ret)
1426 return ret;
1427
1428 DRM_DEBUG_ATOMIC("commiting %p\n", state);
1429
1430 return config->funcs->atomic_commit(state->dev, state, false);
1431}
1432EXPORT_SYMBOL(drm_atomic_commit);
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450int drm_atomic_nonblocking_commit(struct drm_atomic_state *state)
1451{
1452 struct drm_mode_config *config = &state->dev->mode_config;
1453 int ret;
1454
1455 ret = drm_atomic_check_only(state);
1456 if (ret)
1457 return ret;
1458
1459 DRM_DEBUG_ATOMIC("commiting %p nonblocking\n", state);
1460
1461 return config->funcs->atomic_commit(state->dev, state, true);
1462}
1463EXPORT_SYMBOL(drm_atomic_nonblocking_commit);
1464
1465
1466
1467
1468
1469static struct drm_pending_vblank_event *create_vblank_event(
1470 struct drm_device *dev, struct drm_file *file_priv,
1471 struct fence *fence, uint64_t user_data)
1472{
1473 struct drm_pending_vblank_event *e = NULL;
1474 int ret;
1475
1476 e = kzalloc(sizeof *e, GFP_KERNEL);
1477 if (!e)
1478 return NULL;
1479
1480 e->event.base.type = DRM_EVENT_FLIP_COMPLETE;
1481 e->event.base.length = sizeof(e->event);
1482 e->event.user_data = user_data;
1483
1484 if (file_priv) {
1485 ret = drm_event_reserve_init(dev, file_priv, &e->base,
1486 &e->event.base);
1487 if (ret) {
1488 kfree(e);
1489 return NULL;
1490 }
1491 }
1492
1493 e->base.fence = fence;
1494
1495 return e;
1496}
1497
1498static int atomic_set_prop(struct drm_atomic_state *state,
1499 struct drm_mode_object *obj, struct drm_property *prop,
1500 uint64_t prop_value)
1501{
1502 struct drm_mode_object *ref;
1503 int ret;
1504
1505 if (!drm_property_change_valid_get(prop, prop_value, &ref))
1506 return -EINVAL;
1507
1508 switch (obj->type) {
1509 case DRM_MODE_OBJECT_CONNECTOR: {
1510 struct drm_connector *connector = obj_to_connector(obj);
1511 struct drm_connector_state *connector_state;
1512
1513 connector_state = drm_atomic_get_connector_state(state, connector);
1514 if (IS_ERR(connector_state)) {
1515 ret = PTR_ERR(connector_state);
1516 break;
1517 }
1518
1519 ret = drm_atomic_connector_set_property(connector,
1520 connector_state, prop, prop_value);
1521 break;
1522 }
1523 case DRM_MODE_OBJECT_CRTC: {
1524 struct drm_crtc *crtc = obj_to_crtc(obj);
1525 struct drm_crtc_state *crtc_state;
1526
1527 crtc_state = drm_atomic_get_crtc_state(state, crtc);
1528 if (IS_ERR(crtc_state)) {
1529 ret = PTR_ERR(crtc_state);
1530 break;
1531 }
1532
1533 ret = drm_atomic_crtc_set_property(crtc,
1534 crtc_state, prop, prop_value);
1535 break;
1536 }
1537 case DRM_MODE_OBJECT_PLANE: {
1538 struct drm_plane *plane = obj_to_plane(obj);
1539 struct drm_plane_state *plane_state;
1540
1541 plane_state = drm_atomic_get_plane_state(state, plane);
1542 if (IS_ERR(plane_state)) {
1543 ret = PTR_ERR(plane_state);
1544 break;
1545 }
1546
1547 ret = drm_atomic_plane_set_property(plane,
1548 plane_state, prop, prop_value);
1549 break;
1550 }
1551 default:
1552 ret = -EINVAL;
1553 break;
1554 }
1555
1556 drm_property_change_valid_put(prop, ref);
1557 return ret;
1558}
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572void drm_atomic_clean_old_fb(struct drm_device *dev,
1573 unsigned plane_mask,
1574 int ret)
1575{
1576 struct drm_plane *plane;
1577
1578
1579
1580
1581
1582
1583 drm_for_each_plane_mask(plane, dev, plane_mask) {
1584 if (ret == 0) {
1585 struct drm_framebuffer *new_fb = plane->state->fb;
1586 if (new_fb)
1587 drm_framebuffer_reference(new_fb);
1588 plane->fb = new_fb;
1589 plane->crtc = plane->state->crtc;
1590
1591 if (plane->old_fb)
1592 drm_framebuffer_unreference(plane->old_fb);
1593 }
1594 plane->old_fb = NULL;
1595 }
1596}
1597EXPORT_SYMBOL(drm_atomic_clean_old_fb);
1598
1599int drm_mode_atomic_ioctl(struct drm_device *dev,
1600 void *data, struct drm_file *file_priv)
1601{
1602 struct drm_mode_atomic *arg = data;
1603 uint32_t __user *objs_ptr = (uint32_t __user *)(unsigned long)(arg->objs_ptr);
1604 uint32_t __user *count_props_ptr = (uint32_t __user *)(unsigned long)(arg->count_props_ptr);
1605 uint32_t __user *props_ptr = (uint32_t __user *)(unsigned long)(arg->props_ptr);
1606 uint64_t __user *prop_values_ptr = (uint64_t __user *)(unsigned long)(arg->prop_values_ptr);
1607 unsigned int copied_objs, copied_props;
1608 struct drm_atomic_state *state;
1609 struct drm_modeset_acquire_ctx ctx;
1610 struct drm_plane *plane;
1611 struct drm_crtc *crtc;
1612 struct drm_crtc_state *crtc_state;
1613 unsigned plane_mask;
1614 int ret = 0;
1615 unsigned int i, j;
1616
1617
1618 if (!drm_core_check_feature(dev, DRIVER_ATOMIC))
1619 return -EINVAL;
1620
1621
1622
1623
1624
1625 if (!file_priv->atomic)
1626 return -EINVAL;
1627
1628 if (arg->flags & ~DRM_MODE_ATOMIC_FLAGS)
1629 return -EINVAL;
1630
1631 if (arg->reserved)
1632 return -EINVAL;
1633
1634 if ((arg->flags & DRM_MODE_PAGE_FLIP_ASYNC) &&
1635 !dev->mode_config.async_page_flip)
1636 return -EINVAL;
1637
1638
1639 if ((arg->flags & DRM_MODE_ATOMIC_TEST_ONLY) &&
1640 (arg->flags & DRM_MODE_PAGE_FLIP_EVENT))
1641 return -EINVAL;
1642
1643 drm_modeset_acquire_init(&ctx, 0);
1644
1645 state = drm_atomic_state_alloc(dev);
1646 if (!state)
1647 return -ENOMEM;
1648
1649 state->acquire_ctx = &ctx;
1650 state->allow_modeset = !!(arg->flags & DRM_MODE_ATOMIC_ALLOW_MODESET);
1651
1652retry:
1653 plane_mask = 0;
1654 copied_objs = 0;
1655 copied_props = 0;
1656
1657 for (i = 0; i < arg->count_objs; i++) {
1658 uint32_t obj_id, count_props;
1659 struct drm_mode_object *obj;
1660
1661 if (get_user(obj_id, objs_ptr + copied_objs)) {
1662 ret = -EFAULT;
1663 goto out;
1664 }
1665
1666 obj = drm_mode_object_find(dev, obj_id, DRM_MODE_OBJECT_ANY);
1667 if (!obj) {
1668 ret = -ENOENT;
1669 goto out;
1670 }
1671
1672 if (!obj->properties) {
1673 drm_mode_object_unreference(obj);
1674 ret = -ENOENT;
1675 goto out;
1676 }
1677
1678 if (get_user(count_props, count_props_ptr + copied_objs)) {
1679 drm_mode_object_unreference(obj);
1680 ret = -EFAULT;
1681 goto out;
1682 }
1683
1684 copied_objs++;
1685
1686 for (j = 0; j < count_props; j++) {
1687 uint32_t prop_id;
1688 uint64_t prop_value;
1689 struct drm_property *prop;
1690
1691 if (get_user(prop_id, props_ptr + copied_props)) {
1692 drm_mode_object_unreference(obj);
1693 ret = -EFAULT;
1694 goto out;
1695 }
1696
1697 prop = drm_mode_obj_find_prop_id(obj, prop_id);
1698 if (!prop) {
1699 drm_mode_object_unreference(obj);
1700 ret = -ENOENT;
1701 goto out;
1702 }
1703
1704 if (copy_from_user(&prop_value,
1705 prop_values_ptr + copied_props,
1706 sizeof(prop_value))) {
1707 drm_mode_object_unreference(obj);
1708 ret = -EFAULT;
1709 goto out;
1710 }
1711
1712 ret = atomic_set_prop(state, obj, prop, prop_value);
1713 if (ret) {
1714 drm_mode_object_unreference(obj);
1715 goto out;
1716 }
1717
1718 copied_props++;
1719 }
1720
1721 if (obj->type == DRM_MODE_OBJECT_PLANE && count_props &&
1722 !(arg->flags & DRM_MODE_ATOMIC_TEST_ONLY)) {
1723 plane = obj_to_plane(obj);
1724 plane_mask |= (1 << drm_plane_index(plane));
1725 plane->old_fb = plane->fb;
1726 }
1727 drm_mode_object_unreference(obj);
1728 }
1729
1730 if (arg->flags & DRM_MODE_PAGE_FLIP_EVENT) {
1731 for_each_crtc_in_state(state, crtc, crtc_state, i) {
1732 struct drm_pending_vblank_event *e;
1733
1734 e = create_vblank_event(dev, file_priv, NULL,
1735 arg->user_data);
1736 if (!e) {
1737 ret = -ENOMEM;
1738 goto out;
1739 }
1740
1741 crtc_state->event = e;
1742 }
1743 }
1744
1745 if (arg->flags & DRM_MODE_ATOMIC_TEST_ONLY) {
1746
1747
1748
1749
1750 ret = drm_atomic_check_only(state);
1751 } else if (arg->flags & DRM_MODE_ATOMIC_NONBLOCK) {
1752 ret = drm_atomic_nonblocking_commit(state);
1753 } else {
1754 ret = drm_atomic_commit(state);
1755 }
1756
1757out:
1758 drm_atomic_clean_old_fb(dev, plane_mask, ret);
1759
1760 if (ret && arg->flags & DRM_MODE_PAGE_FLIP_EVENT) {
1761
1762
1763
1764
1765
1766
1767 for_each_crtc_in_state(state, crtc, crtc_state, i) {
1768 if (!crtc_state->event)
1769 continue;
1770
1771 drm_event_cancel_free(dev, &crtc_state->event->base);
1772 }
1773 }
1774
1775 if (ret == -EDEADLK) {
1776 drm_atomic_state_clear(state);
1777 drm_modeset_backoff(&ctx);
1778 goto retry;
1779 }
1780
1781 if (ret || arg->flags & DRM_MODE_ATOMIC_TEST_ONLY)
1782 drm_atomic_state_free(state);
1783
1784 drm_modeset_drop_locks(&ctx);
1785 drm_modeset_acquire_fini(&ctx);
1786
1787 return ret;
1788}
1789