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_plane_helper.h>
32
33static void kfree_state(struct drm_atomic_state *state)
34{
35 kfree(state->connectors);
36 kfree(state->connector_states);
37 kfree(state->crtcs);
38 kfree(state->crtc_states);
39 kfree(state->planes);
40 kfree(state->plane_states);
41 kfree(state);
42}
43
44
45
46
47
48
49
50struct drm_atomic_state *
51drm_atomic_state_alloc(struct drm_device *dev)
52{
53 struct drm_atomic_state *state;
54
55 state = kzalloc(sizeof(*state), GFP_KERNEL);
56 if (!state)
57 return NULL;
58
59
60
61
62 state->allow_modeset = true;
63
64 state->num_connector = ACCESS_ONCE(dev->mode_config.num_connector);
65
66 state->crtcs = kcalloc(dev->mode_config.num_crtc,
67 sizeof(*state->crtcs), GFP_KERNEL);
68 if (!state->crtcs)
69 goto fail;
70 state->crtc_states = kcalloc(dev->mode_config.num_crtc,
71 sizeof(*state->crtc_states), GFP_KERNEL);
72 if (!state->crtc_states)
73 goto fail;
74 state->planes = kcalloc(dev->mode_config.num_total_plane,
75 sizeof(*state->planes), GFP_KERNEL);
76 if (!state->planes)
77 goto fail;
78 state->plane_states = kcalloc(dev->mode_config.num_total_plane,
79 sizeof(*state->plane_states), GFP_KERNEL);
80 if (!state->plane_states)
81 goto fail;
82 state->connectors = kcalloc(state->num_connector,
83 sizeof(*state->connectors),
84 GFP_KERNEL);
85 if (!state->connectors)
86 goto fail;
87 state->connector_states = kcalloc(state->num_connector,
88 sizeof(*state->connector_states),
89 GFP_KERNEL);
90 if (!state->connector_states)
91 goto fail;
92
93 state->dev = dev;
94
95 DRM_DEBUG_ATOMIC("Allocate atomic state %p\n", state);
96
97 return state;
98fail:
99 kfree_state(state);
100
101 return NULL;
102}
103EXPORT_SYMBOL(drm_atomic_state_alloc);
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119void drm_atomic_state_clear(struct drm_atomic_state *state)
120{
121 struct drm_device *dev = state->dev;
122 struct drm_mode_config *config = &dev->mode_config;
123 int i;
124
125 DRM_DEBUG_ATOMIC("Clearing atomic state %p\n", state);
126
127 for (i = 0; i < state->num_connector; i++) {
128 struct drm_connector *connector = state->connectors[i];
129
130 if (!connector)
131 continue;
132
133 WARN_ON(!drm_modeset_is_locked(&config->connection_mutex));
134
135 connector->funcs->atomic_destroy_state(connector,
136 state->connector_states[i]);
137 state->connectors[i] = NULL;
138 state->connector_states[i] = NULL;
139 }
140
141 for (i = 0; i < config->num_crtc; i++) {
142 struct drm_crtc *crtc = state->crtcs[i];
143
144 if (!crtc)
145 continue;
146
147 crtc->funcs->atomic_destroy_state(crtc,
148 state->crtc_states[i]);
149 state->crtcs[i] = NULL;
150 state->crtc_states[i] = NULL;
151 }
152
153 for (i = 0; i < config->num_total_plane; i++) {
154 struct drm_plane *plane = state->planes[i];
155
156 if (!plane)
157 continue;
158
159 plane->funcs->atomic_destroy_state(plane,
160 state->plane_states[i]);
161 state->planes[i] = NULL;
162 state->plane_states[i] = NULL;
163 }
164}
165EXPORT_SYMBOL(drm_atomic_state_clear);
166
167
168
169
170
171
172
173
174void drm_atomic_state_free(struct drm_atomic_state *state)
175{
176 if (!state)
177 return;
178
179 drm_atomic_state_clear(state);
180
181 DRM_DEBUG_ATOMIC("Freeing atomic state %p\n", state);
182
183 kfree_state(state);
184}
185EXPORT_SYMBOL(drm_atomic_state_free);
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202struct drm_crtc_state *
203drm_atomic_get_crtc_state(struct drm_atomic_state *state,
204 struct drm_crtc *crtc)
205{
206 int ret, index;
207 struct drm_crtc_state *crtc_state;
208
209 index = drm_crtc_index(crtc);
210
211 if (state->crtc_states[index])
212 return state->crtc_states[index];
213
214 ret = drm_modeset_lock(&crtc->mutex, state->acquire_ctx);
215 if (ret)
216 return ERR_PTR(ret);
217
218 crtc_state = crtc->funcs->atomic_duplicate_state(crtc);
219 if (!crtc_state)
220 return ERR_PTR(-ENOMEM);
221
222 state->crtc_states[index] = crtc_state;
223 state->crtcs[index] = crtc;
224 crtc_state->state = state;
225
226 DRM_DEBUG_ATOMIC("Added [CRTC:%d] %p state to %p\n",
227 crtc->base.id, crtc_state, state);
228
229 return crtc_state;
230}
231EXPORT_SYMBOL(drm_atomic_get_crtc_state);
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249int drm_atomic_crtc_set_property(struct drm_crtc *crtc,
250 struct drm_crtc_state *state, struct drm_property *property,
251 uint64_t val)
252{
253 struct drm_device *dev = crtc->dev;
254 struct drm_mode_config *config = &dev->mode_config;
255
256
257 if (property == config->prop_active)
258 state->active = val;
259 else if (crtc->funcs->atomic_set_property)
260 return crtc->funcs->atomic_set_property(crtc, state, property, val);
261 else
262 return -EINVAL;
263
264 return 0;
265}
266EXPORT_SYMBOL(drm_atomic_crtc_set_property);
267
268
269
270
271
272
273
274int drm_atomic_crtc_get_property(struct drm_crtc *crtc,
275 const struct drm_crtc_state *state,
276 struct drm_property *property, uint64_t *val)
277{
278 struct drm_device *dev = crtc->dev;
279 struct drm_mode_config *config = &dev->mode_config;
280
281 if (property == config->prop_active)
282 *val = state->active;
283 else if (crtc->funcs->atomic_get_property)
284 return crtc->funcs->atomic_get_property(crtc, state, property, val);
285 else
286 return -EINVAL;
287
288 return 0;
289}
290
291
292
293
294
295
296
297
298
299
300
301static int drm_atomic_crtc_check(struct drm_crtc *crtc,
302 struct drm_crtc_state *state)
303{
304
305
306
307
308
309
310
311
312 if (state->active && !state->enable) {
313 DRM_DEBUG_ATOMIC("[CRTC:%d] active without enabled\n",
314 crtc->base.id);
315 return -EINVAL;
316 }
317
318 return 0;
319}
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336struct drm_plane_state *
337drm_atomic_get_plane_state(struct drm_atomic_state *state,
338 struct drm_plane *plane)
339{
340 int ret, index;
341 struct drm_plane_state *plane_state;
342
343 index = drm_plane_index(plane);
344
345 if (state->plane_states[index])
346 return state->plane_states[index];
347
348 ret = drm_modeset_lock(&plane->mutex, state->acquire_ctx);
349 if (ret)
350 return ERR_PTR(ret);
351
352 plane_state = plane->funcs->atomic_duplicate_state(plane);
353 if (!plane_state)
354 return ERR_PTR(-ENOMEM);
355
356 state->plane_states[index] = plane_state;
357 state->planes[index] = plane;
358 plane_state->state = state;
359
360 DRM_DEBUG_ATOMIC("Added [PLANE:%d] %p state to %p\n",
361 plane->base.id, plane_state, state);
362
363 if (plane_state->crtc) {
364 struct drm_crtc_state *crtc_state;
365
366 crtc_state = drm_atomic_get_crtc_state(state,
367 plane_state->crtc);
368 if (IS_ERR(crtc_state))
369 return ERR_CAST(crtc_state);
370 }
371
372 return plane_state;
373}
374EXPORT_SYMBOL(drm_atomic_get_plane_state);
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392int drm_atomic_plane_set_property(struct drm_plane *plane,
393 struct drm_plane_state *state, struct drm_property *property,
394 uint64_t val)
395{
396 struct drm_device *dev = plane->dev;
397 struct drm_mode_config *config = &dev->mode_config;
398
399 if (property == config->prop_fb_id) {
400 struct drm_framebuffer *fb = drm_framebuffer_lookup(dev, val);
401 drm_atomic_set_fb_for_plane(state, fb);
402 if (fb)
403 drm_framebuffer_unreference(fb);
404 } else if (property == config->prop_crtc_id) {
405 struct drm_crtc *crtc = drm_crtc_find(dev, val);
406 return drm_atomic_set_crtc_for_plane(state, crtc);
407 } else if (property == config->prop_crtc_x) {
408 state->crtc_x = U642I64(val);
409 } else if (property == config->prop_crtc_y) {
410 state->crtc_y = U642I64(val);
411 } else if (property == config->prop_crtc_w) {
412 state->crtc_w = val;
413 } else if (property == config->prop_crtc_h) {
414 state->crtc_h = val;
415 } else if (property == config->prop_src_x) {
416 state->src_x = val;
417 } else if (property == config->prop_src_y) {
418 state->src_y = val;
419 } else if (property == config->prop_src_w) {
420 state->src_w = val;
421 } else if (property == config->prop_src_h) {
422 state->src_h = val;
423 } else if (property == config->rotation_property) {
424 state->rotation = val;
425 } else if (plane->funcs->atomic_set_property) {
426 return plane->funcs->atomic_set_property(plane, state,
427 property, val);
428 } else {
429 return -EINVAL;
430 }
431
432 return 0;
433}
434EXPORT_SYMBOL(drm_atomic_plane_set_property);
435
436
437
438
439
440
441
442static int
443drm_atomic_plane_get_property(struct drm_plane *plane,
444 const struct drm_plane_state *state,
445 struct drm_property *property, uint64_t *val)
446{
447 struct drm_device *dev = plane->dev;
448 struct drm_mode_config *config = &dev->mode_config;
449
450 if (property == config->prop_fb_id) {
451 *val = (state->fb) ? state->fb->base.id : 0;
452 } else if (property == config->prop_crtc_id) {
453 *val = (state->crtc) ? state->crtc->base.id : 0;
454 } else if (property == config->prop_crtc_x) {
455 *val = I642U64(state->crtc_x);
456 } else if (property == config->prop_crtc_y) {
457 *val = I642U64(state->crtc_y);
458 } else if (property == config->prop_crtc_w) {
459 *val = state->crtc_w;
460 } else if (property == config->prop_crtc_h) {
461 *val = state->crtc_h;
462 } else if (property == config->prop_src_x) {
463 *val = state->src_x;
464 } else if (property == config->prop_src_y) {
465 *val = state->src_y;
466 } else if (property == config->prop_src_w) {
467 *val = state->src_w;
468 } else if (property == config->prop_src_h) {
469 *val = state->src_h;
470 } else if (property == config->rotation_property) {
471 *val = state->rotation;
472 } else if (plane->funcs->atomic_get_property) {
473 return plane->funcs->atomic_get_property(plane, state, property, val);
474 } else {
475 return -EINVAL;
476 }
477
478 return 0;
479}
480
481
482
483
484
485
486
487
488
489
490
491static int drm_atomic_plane_check(struct drm_plane *plane,
492 struct drm_plane_state *state)
493{
494 unsigned int fb_width, fb_height;
495 int ret;
496
497
498 if (WARN_ON(state->crtc && !state->fb)) {
499 DRM_DEBUG_ATOMIC("CRTC set but no FB\n");
500 return -EINVAL;
501 } else if (WARN_ON(state->fb && !state->crtc)) {
502 DRM_DEBUG_ATOMIC("FB set but no CRTC\n");
503 return -EINVAL;
504 }
505
506
507 if (!state->crtc)
508 return 0;
509
510
511 if (!(plane->possible_crtcs & drm_crtc_mask(state->crtc))) {
512 DRM_DEBUG_ATOMIC("Invalid crtc for plane\n");
513 return -EINVAL;
514 }
515
516
517 ret = drm_plane_check_pixel_format(plane, state->fb->pixel_format);
518 if (ret) {
519 DRM_DEBUG_ATOMIC("Invalid pixel format %s\n",
520 drm_get_format_name(state->fb->pixel_format));
521 return ret;
522 }
523
524
525 if (state->crtc_w > INT_MAX ||
526 state->crtc_x > INT_MAX - (int32_t) state->crtc_w ||
527 state->crtc_h > INT_MAX ||
528 state->crtc_y > INT_MAX - (int32_t) state->crtc_h) {
529 DRM_DEBUG_ATOMIC("Invalid CRTC coordinates %ux%u+%d+%d\n",
530 state->crtc_w, state->crtc_h,
531 state->crtc_x, state->crtc_y);
532 return -ERANGE;
533 }
534
535 fb_width = state->fb->width << 16;
536 fb_height = state->fb->height << 16;
537
538
539 if (state->src_w > fb_width ||
540 state->src_x > fb_width - state->src_w ||
541 state->src_h > fb_height ||
542 state->src_y > fb_height - state->src_h) {
543 DRM_DEBUG_ATOMIC("Invalid source coordinates "
544 "%u.%06ux%u.%06u+%u.%06u+%u.%06u\n",
545 state->src_w >> 16, ((state->src_w & 0xffff) * 15625) >> 10,
546 state->src_h >> 16, ((state->src_h & 0xffff) * 15625) >> 10,
547 state->src_x >> 16, ((state->src_x & 0xffff) * 15625) >> 10,
548 state->src_y >> 16, ((state->src_y & 0xffff) * 15625) >> 10);
549 return -ENOSPC;
550 }
551
552 return 0;
553}
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570struct drm_connector_state *
571drm_atomic_get_connector_state(struct drm_atomic_state *state,
572 struct drm_connector *connector)
573{
574 int ret, index;
575 struct drm_mode_config *config = &connector->dev->mode_config;
576 struct drm_connector_state *connector_state;
577
578 ret = drm_modeset_lock(&config->connection_mutex, state->acquire_ctx);
579 if (ret)
580 return ERR_PTR(ret);
581
582 index = drm_connector_index(connector);
583
584
585
586
587
588
589
590
591
592
593
594 if (index >= state->num_connector) {
595 DRM_DEBUG_ATOMIC("Hot-added connector would overflow state array, restarting\n");
596 return ERR_PTR(-EAGAIN);
597 }
598
599 if (state->connector_states[index])
600 return state->connector_states[index];
601
602 connector_state = connector->funcs->atomic_duplicate_state(connector);
603 if (!connector_state)
604 return ERR_PTR(-ENOMEM);
605
606 state->connector_states[index] = connector_state;
607 state->connectors[index] = connector;
608 connector_state->state = state;
609
610 DRM_DEBUG_ATOMIC("Added [CONNECTOR:%d] %p state to %p\n",
611 connector->base.id, connector_state, state);
612
613 if (connector_state->crtc) {
614 struct drm_crtc_state *crtc_state;
615
616 crtc_state = drm_atomic_get_crtc_state(state,
617 connector_state->crtc);
618 if (IS_ERR(crtc_state))
619 return ERR_CAST(crtc_state);
620 }
621
622 return connector_state;
623}
624EXPORT_SYMBOL(drm_atomic_get_connector_state);
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642int drm_atomic_connector_set_property(struct drm_connector *connector,
643 struct drm_connector_state *state, struct drm_property *property,
644 uint64_t val)
645{
646 struct drm_device *dev = connector->dev;
647 struct drm_mode_config *config = &dev->mode_config;
648
649 if (property == config->prop_crtc_id) {
650 struct drm_crtc *crtc = drm_crtc_find(dev, val);
651 return drm_atomic_set_crtc_for_connector(state, crtc);
652 } else if (property == config->dpms_property) {
653
654
655
656
657 return -EINVAL;
658 } else if (connector->funcs->atomic_set_property) {
659 return connector->funcs->atomic_set_property(connector,
660 state, property, val);
661 } else {
662 return -EINVAL;
663 }
664}
665EXPORT_SYMBOL(drm_atomic_connector_set_property);
666
667
668
669
670
671
672
673static int
674drm_atomic_connector_get_property(struct drm_connector *connector,
675 const struct drm_connector_state *state,
676 struct drm_property *property, uint64_t *val)
677{
678 struct drm_device *dev = connector->dev;
679 struct drm_mode_config *config = &dev->mode_config;
680
681 if (property == config->prop_crtc_id) {
682 *val = (state->crtc) ? state->crtc->base.id : 0;
683 } else if (property == config->dpms_property) {
684 *val = connector->dpms;
685 } else if (connector->funcs->atomic_get_property) {
686 return connector->funcs->atomic_get_property(connector,
687 state, property, val);
688 } else {
689 return -EINVAL;
690 }
691
692 return 0;
693}
694
695int drm_atomic_get_property(struct drm_mode_object *obj,
696 struct drm_property *property, uint64_t *val)
697{
698 struct drm_device *dev = property->dev;
699 int ret;
700
701 switch (obj->type) {
702 case DRM_MODE_OBJECT_CONNECTOR: {
703 struct drm_connector *connector = obj_to_connector(obj);
704 WARN_ON(!drm_modeset_is_locked(&dev->mode_config.connection_mutex));
705 ret = drm_atomic_connector_get_property(connector,
706 connector->state, property, val);
707 break;
708 }
709 case DRM_MODE_OBJECT_CRTC: {
710 struct drm_crtc *crtc = obj_to_crtc(obj);
711 WARN_ON(!drm_modeset_is_locked(&crtc->mutex));
712 ret = drm_atomic_crtc_get_property(crtc,
713 crtc->state, property, val);
714 break;
715 }
716 case DRM_MODE_OBJECT_PLANE: {
717 struct drm_plane *plane = obj_to_plane(obj);
718 WARN_ON(!drm_modeset_is_locked(&plane->mutex));
719 ret = drm_atomic_plane_get_property(plane,
720 plane->state, property, val);
721 break;
722 }
723 default:
724 ret = -EINVAL;
725 break;
726 }
727
728 return ret;
729}
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745int
746drm_atomic_set_crtc_for_plane(struct drm_plane_state *plane_state,
747 struct drm_crtc *crtc)
748{
749 struct drm_plane *plane = plane_state->plane;
750 struct drm_crtc_state *crtc_state;
751
752 if (plane_state->crtc) {
753 crtc_state = drm_atomic_get_crtc_state(plane_state->state,
754 plane_state->crtc);
755 if (WARN_ON(IS_ERR(crtc_state)))
756 return PTR_ERR(crtc_state);
757
758 crtc_state->plane_mask &= ~(1 << drm_plane_index(plane));
759 }
760
761 plane_state->crtc = crtc;
762
763 if (crtc) {
764 crtc_state = drm_atomic_get_crtc_state(plane_state->state,
765 crtc);
766 if (IS_ERR(crtc_state))
767 return PTR_ERR(crtc_state);
768 crtc_state->plane_mask |= (1 << drm_plane_index(plane));
769 }
770
771 if (crtc)
772 DRM_DEBUG_ATOMIC("Link plane state %p to [CRTC:%d]\n",
773 plane_state, crtc->base.id);
774 else
775 DRM_DEBUG_ATOMIC("Link plane state %p to [NOCRTC]\n",
776 plane_state);
777
778 return 0;
779}
780EXPORT_SYMBOL(drm_atomic_set_crtc_for_plane);
781
782
783
784
785
786
787
788
789
790
791
792void
793drm_atomic_set_fb_for_plane(struct drm_plane_state *plane_state,
794 struct drm_framebuffer *fb)
795{
796 if (plane_state->fb)
797 drm_framebuffer_unreference(plane_state->fb);
798 if (fb)
799 drm_framebuffer_reference(fb);
800 plane_state->fb = fb;
801
802 if (fb)
803 DRM_DEBUG_ATOMIC("Set [FB:%d] for plane state %p\n",
804 fb->base.id, plane_state);
805 else
806 DRM_DEBUG_ATOMIC("Set [NOFB] for plane state %p\n",
807 plane_state);
808}
809EXPORT_SYMBOL(drm_atomic_set_fb_for_plane);
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825int
826drm_atomic_set_crtc_for_connector(struct drm_connector_state *conn_state,
827 struct drm_crtc *crtc)
828{
829 struct drm_crtc_state *crtc_state;
830
831 if (crtc) {
832 crtc_state = drm_atomic_get_crtc_state(conn_state->state, crtc);
833 if (IS_ERR(crtc_state))
834 return PTR_ERR(crtc_state);
835 }
836
837 conn_state->crtc = crtc;
838
839 if (crtc)
840 DRM_DEBUG_ATOMIC("Link connector state %p to [CRTC:%d]\n",
841 conn_state, crtc->base.id);
842 else
843 DRM_DEBUG_ATOMIC("Link connector state %p to [NOCRTC]\n",
844 conn_state);
845
846 return 0;
847}
848EXPORT_SYMBOL(drm_atomic_set_crtc_for_connector);
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867int
868drm_atomic_add_affected_connectors(struct drm_atomic_state *state,
869 struct drm_crtc *crtc)
870{
871 struct drm_mode_config *config = &state->dev->mode_config;
872 struct drm_connector *connector;
873 struct drm_connector_state *conn_state;
874 int ret;
875
876 ret = drm_modeset_lock(&config->connection_mutex, state->acquire_ctx);
877 if (ret)
878 return ret;
879
880 DRM_DEBUG_ATOMIC("Adding all current connectors for [CRTC:%d] to %p\n",
881 crtc->base.id, state);
882
883
884
885
886
887 list_for_each_entry(connector, &config->connector_list, head) {
888 if (connector->state->crtc != crtc)
889 continue;
890
891 conn_state = drm_atomic_get_connector_state(state, connector);
892 if (IS_ERR(conn_state))
893 return PTR_ERR(conn_state);
894 }
895
896 return 0;
897}
898EXPORT_SYMBOL(drm_atomic_add_affected_connectors);
899
900
901
902
903
904
905
906
907
908int
909drm_atomic_connectors_for_crtc(struct drm_atomic_state *state,
910 struct drm_crtc *crtc)
911{
912 struct drm_connector *connector;
913 struct drm_connector_state *conn_state;
914
915 int i, num_connected_connectors = 0;
916
917 for_each_connector_in_state(state, connector, conn_state, i) {
918 if (conn_state->crtc == crtc)
919 num_connected_connectors++;
920 }
921
922 DRM_DEBUG_ATOMIC("State %p has %i connectors for [CRTC:%d]\n",
923 state, num_connected_connectors, crtc->base.id);
924
925 return num_connected_connectors;
926}
927EXPORT_SYMBOL(drm_atomic_connectors_for_crtc);
928
929
930
931
932
933
934
935
936
937void drm_atomic_legacy_backoff(struct drm_atomic_state *state)
938{
939 int ret;
940
941retry:
942 drm_modeset_backoff(state->acquire_ctx);
943
944 ret = drm_modeset_lock(&state->dev->mode_config.connection_mutex,
945 state->acquire_ctx);
946 if (ret)
947 goto retry;
948 ret = drm_modeset_lock_all_crtcs(state->dev,
949 state->acquire_ctx);
950 if (ret)
951 goto retry;
952}
953EXPORT_SYMBOL(drm_atomic_legacy_backoff);
954
955
956
957
958
959
960
961
962
963
964
965
966int drm_atomic_check_only(struct drm_atomic_state *state)
967{
968 struct drm_device *dev = state->dev;
969 struct drm_mode_config *config = &dev->mode_config;
970 struct drm_plane *plane;
971 struct drm_plane_state *plane_state;
972 struct drm_crtc *crtc;
973 struct drm_crtc_state *crtc_state;
974 int i, ret = 0;
975
976 DRM_DEBUG_ATOMIC("checking %p\n", state);
977
978 for_each_plane_in_state(state, plane, plane_state, i) {
979 ret = drm_atomic_plane_check(plane, plane_state);
980 if (ret) {
981 DRM_DEBUG_ATOMIC("[PLANE:%d] atomic core check failed\n",
982 plane->base.id);
983 return ret;
984 }
985 }
986
987 for_each_crtc_in_state(state, crtc, crtc_state, i) {
988 ret = drm_atomic_crtc_check(crtc, crtc_state);
989 if (ret) {
990 DRM_DEBUG_ATOMIC("[CRTC:%d] atomic core check failed\n",
991 crtc->base.id);
992 return ret;
993 }
994 }
995
996 if (config->funcs->atomic_check)
997 ret = config->funcs->atomic_check(state->dev, state);
998
999 if (!state->allow_modeset) {
1000 for_each_crtc_in_state(state, crtc, crtc_state, i) {
1001 if (crtc_state->mode_changed ||
1002 crtc_state->active_changed) {
1003 DRM_DEBUG_ATOMIC("[CRTC:%d] requires full modeset\n",
1004 crtc->base.id);
1005 return -EINVAL;
1006 }
1007 }
1008 }
1009
1010 return ret;
1011}
1012EXPORT_SYMBOL(drm_atomic_check_only);
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030int drm_atomic_commit(struct drm_atomic_state *state)
1031{
1032 struct drm_mode_config *config = &state->dev->mode_config;
1033 int ret;
1034
1035 ret = drm_atomic_check_only(state);
1036 if (ret)
1037 return ret;
1038
1039 DRM_DEBUG_ATOMIC("commiting %p\n", state);
1040
1041 return config->funcs->atomic_commit(state->dev, state, false);
1042}
1043EXPORT_SYMBOL(drm_atomic_commit);
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061int drm_atomic_async_commit(struct drm_atomic_state *state)
1062{
1063 struct drm_mode_config *config = &state->dev->mode_config;
1064 int ret;
1065
1066 ret = drm_atomic_check_only(state);
1067 if (ret)
1068 return ret;
1069
1070 DRM_DEBUG_ATOMIC("commiting %p asynchronously\n", state);
1071
1072 return config->funcs->atomic_commit(state->dev, state, true);
1073}
1074EXPORT_SYMBOL(drm_atomic_async_commit);
1075
1076
1077
1078
1079
1080static struct drm_pending_vblank_event *create_vblank_event(
1081 struct drm_device *dev, struct drm_file *file_priv, uint64_t user_data)
1082{
1083 struct drm_pending_vblank_event *e = NULL;
1084 unsigned long flags;
1085
1086 spin_lock_irqsave(&dev->event_lock, flags);
1087 if (file_priv->event_space < sizeof e->event) {
1088 spin_unlock_irqrestore(&dev->event_lock, flags);
1089 goto out;
1090 }
1091 file_priv->event_space -= sizeof e->event;
1092 spin_unlock_irqrestore(&dev->event_lock, flags);
1093
1094 e = kzalloc(sizeof *e, GFP_KERNEL);
1095 if (e == NULL) {
1096 spin_lock_irqsave(&dev->event_lock, flags);
1097 file_priv->event_space += sizeof e->event;
1098 spin_unlock_irqrestore(&dev->event_lock, flags);
1099 goto out;
1100 }
1101
1102 e->event.base.type = DRM_EVENT_FLIP_COMPLETE;
1103 e->event.base.length = sizeof e->event;
1104 e->event.user_data = user_data;
1105 e->base.event = &e->event.base;
1106 e->base.file_priv = file_priv;
1107 e->base.destroy = (void (*) (struct drm_pending_event *)) kfree;
1108
1109out:
1110 return e;
1111}
1112
1113static void destroy_vblank_event(struct drm_device *dev,
1114 struct drm_file *file_priv, struct drm_pending_vblank_event *e)
1115{
1116 unsigned long flags;
1117
1118 spin_lock_irqsave(&dev->event_lock, flags);
1119 file_priv->event_space += sizeof e->event;
1120 spin_unlock_irqrestore(&dev->event_lock, flags);
1121 kfree(e);
1122}
1123
1124static int atomic_set_prop(struct drm_atomic_state *state,
1125 struct drm_mode_object *obj, struct drm_property *prop,
1126 uint64_t prop_value)
1127{
1128 struct drm_mode_object *ref;
1129 int ret;
1130
1131 if (!drm_property_change_valid_get(prop, prop_value, &ref))
1132 return -EINVAL;
1133
1134 switch (obj->type) {
1135 case DRM_MODE_OBJECT_CONNECTOR: {
1136 struct drm_connector *connector = obj_to_connector(obj);
1137 struct drm_connector_state *connector_state;
1138
1139 connector_state = drm_atomic_get_connector_state(state, connector);
1140 if (IS_ERR(connector_state)) {
1141 ret = PTR_ERR(connector_state);
1142 break;
1143 }
1144
1145 ret = drm_atomic_connector_set_property(connector,
1146 connector_state, prop, prop_value);
1147 break;
1148 }
1149 case DRM_MODE_OBJECT_CRTC: {
1150 struct drm_crtc *crtc = obj_to_crtc(obj);
1151 struct drm_crtc_state *crtc_state;
1152
1153 crtc_state = drm_atomic_get_crtc_state(state, crtc);
1154 if (IS_ERR(crtc_state)) {
1155 ret = PTR_ERR(crtc_state);
1156 break;
1157 }
1158
1159 ret = drm_atomic_crtc_set_property(crtc,
1160 crtc_state, prop, prop_value);
1161 break;
1162 }
1163 case DRM_MODE_OBJECT_PLANE: {
1164 struct drm_plane *plane = obj_to_plane(obj);
1165 struct drm_plane_state *plane_state;
1166
1167 plane_state = drm_atomic_get_plane_state(state, plane);
1168 if (IS_ERR(plane_state)) {
1169 ret = PTR_ERR(plane_state);
1170 break;
1171 }
1172
1173 ret = drm_atomic_plane_set_property(plane,
1174 plane_state, prop, prop_value);
1175 break;
1176 }
1177 default:
1178 ret = -EINVAL;
1179 break;
1180 }
1181
1182 drm_property_change_valid_put(prop, ref);
1183 return ret;
1184}
1185
1186int drm_mode_atomic_ioctl(struct drm_device *dev,
1187 void *data, struct drm_file *file_priv)
1188{
1189 struct drm_mode_atomic *arg = data;
1190 uint32_t __user *objs_ptr = (uint32_t __user *)(unsigned long)(arg->objs_ptr);
1191 uint32_t __user *count_props_ptr = (uint32_t __user *)(unsigned long)(arg->count_props_ptr);
1192 uint32_t __user *props_ptr = (uint32_t __user *)(unsigned long)(arg->props_ptr);
1193 uint64_t __user *prop_values_ptr = (uint64_t __user *)(unsigned long)(arg->prop_values_ptr);
1194 unsigned int copied_objs, copied_props;
1195 struct drm_atomic_state *state;
1196 struct drm_modeset_acquire_ctx ctx;
1197 struct drm_plane *plane;
1198 struct drm_crtc *crtc;
1199 struct drm_crtc_state *crtc_state;
1200 unsigned plane_mask = 0;
1201 int ret = 0;
1202 unsigned int i, j;
1203
1204
1205 if (!drm_core_check_feature(dev, DRIVER_ATOMIC))
1206 return -EINVAL;
1207
1208
1209
1210
1211
1212 if (!file_priv->atomic)
1213 return -EINVAL;
1214
1215 if (arg->flags & ~DRM_MODE_ATOMIC_FLAGS)
1216 return -EINVAL;
1217
1218 if (arg->reserved)
1219 return -EINVAL;
1220
1221 if ((arg->flags & DRM_MODE_PAGE_FLIP_ASYNC) &&
1222 !dev->mode_config.async_page_flip)
1223 return -EINVAL;
1224
1225
1226 if ((arg->flags & DRM_MODE_ATOMIC_TEST_ONLY) &&
1227 (arg->flags & DRM_MODE_PAGE_FLIP_EVENT))
1228 return -EINVAL;
1229
1230 drm_modeset_acquire_init(&ctx, 0);
1231
1232 state = drm_atomic_state_alloc(dev);
1233 if (!state)
1234 return -ENOMEM;
1235
1236 state->acquire_ctx = &ctx;
1237 state->allow_modeset = !!(arg->flags & DRM_MODE_ATOMIC_ALLOW_MODESET);
1238
1239retry:
1240 copied_objs = 0;
1241 copied_props = 0;
1242
1243 for (i = 0; i < arg->count_objs; i++) {
1244 uint32_t obj_id, count_props;
1245 struct drm_mode_object *obj;
1246
1247 if (get_user(obj_id, objs_ptr + copied_objs)) {
1248 ret = -EFAULT;
1249 goto fail;
1250 }
1251
1252 obj = drm_mode_object_find(dev, obj_id, DRM_MODE_OBJECT_ANY);
1253 if (!obj || !obj->properties) {
1254 ret = -ENOENT;
1255 goto fail;
1256 }
1257
1258 if (obj->type == DRM_MODE_OBJECT_PLANE) {
1259 plane = obj_to_plane(obj);
1260 plane_mask |= (1 << drm_plane_index(plane));
1261 plane->old_fb = plane->fb;
1262 }
1263
1264 if (get_user(count_props, count_props_ptr + copied_objs)) {
1265 ret = -EFAULT;
1266 goto fail;
1267 }
1268
1269 copied_objs++;
1270
1271 for (j = 0; j < count_props; j++) {
1272 uint32_t prop_id;
1273 uint64_t prop_value;
1274 struct drm_property *prop;
1275
1276 if (get_user(prop_id, props_ptr + copied_props)) {
1277 ret = -EFAULT;
1278 goto fail;
1279 }
1280
1281 prop = drm_property_find(dev, prop_id);
1282 if (!prop) {
1283 ret = -ENOENT;
1284 goto fail;
1285 }
1286
1287 if (copy_from_user(&prop_value,
1288 prop_values_ptr + copied_props,
1289 sizeof(prop_value))) {
1290 ret = -EFAULT;
1291 goto fail;
1292 }
1293
1294 ret = atomic_set_prop(state, obj, prop, prop_value);
1295 if (ret)
1296 goto fail;
1297
1298 copied_props++;
1299 }
1300 }
1301
1302 if (arg->flags & DRM_MODE_PAGE_FLIP_EVENT) {
1303 for_each_crtc_in_state(state, crtc, crtc_state, i) {
1304 struct drm_pending_vblank_event *e;
1305
1306 e = create_vblank_event(dev, file_priv, arg->user_data);
1307 if (!e) {
1308 ret = -ENOMEM;
1309 goto fail;
1310 }
1311
1312 crtc_state->event = e;
1313 }
1314 }
1315
1316 if (arg->flags & DRM_MODE_ATOMIC_TEST_ONLY) {
1317 ret = drm_atomic_check_only(state);
1318
1319 drm_atomic_state_free(state);
1320 } else if (arg->flags & DRM_MODE_ATOMIC_NONBLOCK) {
1321 ret = drm_atomic_async_commit(state);
1322 } else {
1323 ret = drm_atomic_commit(state);
1324 }
1325
1326
1327
1328
1329
1330
1331 drm_for_each_plane_mask(plane, dev, plane_mask) {
1332 if (ret == 0) {
1333 struct drm_framebuffer *new_fb = plane->state->fb;
1334 if (new_fb)
1335 drm_framebuffer_reference(new_fb);
1336 plane->fb = new_fb;
1337 plane->crtc = plane->state->crtc;
1338 } else {
1339 plane->old_fb = NULL;
1340 }
1341 if (plane->old_fb) {
1342 drm_framebuffer_unreference(plane->old_fb);
1343 plane->old_fb = NULL;
1344 }
1345 }
1346
1347 drm_modeset_drop_locks(&ctx);
1348 drm_modeset_acquire_fini(&ctx);
1349
1350 return ret;
1351
1352fail:
1353 if (ret == -EDEADLK)
1354 goto backoff;
1355
1356 if (arg->flags & DRM_MODE_PAGE_FLIP_EVENT) {
1357 for_each_crtc_in_state(state, crtc, crtc_state, i) {
1358 destroy_vblank_event(dev, file_priv, crtc_state->event);
1359 crtc_state->event = NULL;
1360 }
1361 }
1362
1363 drm_atomic_state_free(state);
1364
1365 drm_modeset_drop_locks(&ctx);
1366 drm_modeset_acquire_fini(&ctx);
1367
1368 return ret;
1369
1370backoff:
1371 drm_atomic_state_clear(state);
1372 drm_modeset_backoff(&ctx);
1373
1374 goto retry;
1375}
1376