Line data Source code
1 : /*
2 : * Copyright (C) 2014 Red Hat
3 : * Copyright (C) 2014 Intel Corp.
4 : * Copyright (C) 2018 Intel Corp.
5 : * Copyright (c) 2020, The Linux Foundation. All rights reserved.
6 : *
7 : * Permission is hereby granted, free of charge, to any person obtaining a
8 : * copy of this software and associated documentation files (the "Software"),
9 : * to deal in the Software without restriction, including without limitation
10 : * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11 : * and/or sell copies of the Software, and to permit persons to whom the
12 : * Software is furnished to do so, subject to the following conditions:
13 : *
14 : * The above copyright notice and this permission notice shall be included in
15 : * all copies or substantial portions of the Software.
16 : *
17 : * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 : * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 : * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 : * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
21 : * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
22 : * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
23 : * OTHER DEALINGS IN THE SOFTWARE.
24 : *
25 : * Authors:
26 : * Rob Clark <robdclark@gmail.com>
27 : * Daniel Vetter <daniel.vetter@ffwll.ch>
28 : */
29 :
30 : #include <drm/drm_atomic_uapi.h>
31 : #include <drm/drm_atomic.h>
32 : #include <drm/drm_framebuffer.h>
33 : #include <drm/drm_print.h>
34 : #include <drm/drm_drv.h>
35 : #include <drm/drm_writeback.h>
36 : #include <drm/drm_vblank.h>
37 :
38 : #include <linux/dma-fence.h>
39 : #include <linux/uaccess.h>
40 : #include <linux/sync_file.h>
41 : #include <linux/file.h>
42 :
43 : #include "drm_crtc_internal.h"
44 :
45 : /**
46 : * DOC: overview
47 : *
48 : * This file contains the marshalling and demarshalling glue for the atomic UAPI
49 : * in all its forms: The monster ATOMIC IOCTL itself, code for GET_PROPERTY and
50 : * SET_PROPERTY IOCTLs. Plus interface functions for compatibility helpers and
51 : * drivers which have special needs to construct their own atomic updates, e.g.
52 : * for load detect or similar.
53 : */
54 :
55 : /**
56 : * drm_atomic_set_mode_for_crtc - set mode for CRTC
57 : * @state: the CRTC whose incoming state to update
58 : * @mode: kernel-internal mode to use for the CRTC, or NULL to disable
59 : *
60 : * Set a mode (originating from the kernel) on the desired CRTC state and update
61 : * the enable property.
62 : *
63 : * RETURNS:
64 : * Zero on success, error code on failure. Cannot return -EDEADLK.
65 : */
66 0 : int drm_atomic_set_mode_for_crtc(struct drm_crtc_state *state,
67 : const struct drm_display_mode *mode)
68 : {
69 0 : struct drm_crtc *crtc = state->crtc;
70 : struct drm_mode_modeinfo umode;
71 :
72 : /* Early return for no change. */
73 0 : if (mode && memcmp(&state->mode, mode, sizeof(*mode)) == 0)
74 : return 0;
75 :
76 0 : drm_property_blob_put(state->mode_blob);
77 0 : state->mode_blob = NULL;
78 :
79 0 : if (mode) {
80 : struct drm_property_blob *blob;
81 :
82 0 : drm_mode_convert_to_umode(&umode, mode);
83 0 : blob = drm_property_create_blob(crtc->dev,
84 : sizeof(umode), &umode);
85 0 : if (IS_ERR(blob))
86 0 : return PTR_ERR(blob);
87 :
88 0 : drm_mode_copy(&state->mode, mode);
89 :
90 0 : state->mode_blob = blob;
91 0 : state->enable = true;
92 0 : drm_dbg_atomic(crtc->dev,
93 : "Set [MODE:%s] for [CRTC:%d:%s] state %p\n",
94 : mode->name, crtc->base.id, crtc->name, state);
95 : } else {
96 0 : memset(&state->mode, 0, sizeof(state->mode));
97 0 : state->enable = false;
98 0 : drm_dbg_atomic(crtc->dev,
99 : "Set [NOMODE] for [CRTC:%d:%s] state %p\n",
100 : crtc->base.id, crtc->name, state);
101 : }
102 :
103 : return 0;
104 : }
105 : EXPORT_SYMBOL(drm_atomic_set_mode_for_crtc);
106 :
107 : /**
108 : * drm_atomic_set_mode_prop_for_crtc - set mode for CRTC
109 : * @state: the CRTC whose incoming state to update
110 : * @blob: pointer to blob property to use for mode
111 : *
112 : * Set a mode (originating from a blob property) on the desired CRTC state.
113 : * This function will take a reference on the blob property for the CRTC state,
114 : * and release the reference held on the state's existing mode property, if any
115 : * was set.
116 : *
117 : * RETURNS:
118 : * Zero on success, error code on failure. Cannot return -EDEADLK.
119 : */
120 0 : int drm_atomic_set_mode_prop_for_crtc(struct drm_crtc_state *state,
121 : struct drm_property_blob *blob)
122 : {
123 0 : struct drm_crtc *crtc = state->crtc;
124 :
125 0 : if (blob == state->mode_blob)
126 : return 0;
127 :
128 0 : drm_property_blob_put(state->mode_blob);
129 0 : state->mode_blob = NULL;
130 :
131 0 : memset(&state->mode, 0, sizeof(state->mode));
132 :
133 0 : if (blob) {
134 : int ret;
135 :
136 0 : if (blob->length != sizeof(struct drm_mode_modeinfo)) {
137 0 : drm_dbg_atomic(crtc->dev,
138 : "[CRTC:%d:%s] bad mode blob length: %zu\n",
139 : crtc->base.id, crtc->name,
140 : blob->length);
141 0 : return -EINVAL;
142 : }
143 :
144 0 : ret = drm_mode_convert_umode(crtc->dev,
145 0 : &state->mode, blob->data);
146 0 : if (ret) {
147 0 : drm_dbg_atomic(crtc->dev,
148 : "[CRTC:%d:%s] invalid mode (ret=%d, status=%s):\n",
149 : crtc->base.id, crtc->name,
150 : ret, drm_get_mode_status_name(state->mode.status));
151 0 : drm_mode_debug_printmodeline(&state->mode);
152 0 : return -EINVAL;
153 : }
154 :
155 0 : state->mode_blob = drm_property_blob_get(blob);
156 0 : state->enable = true;
157 0 : drm_dbg_atomic(crtc->dev,
158 : "Set [MODE:%s] for [CRTC:%d:%s] state %p\n",
159 : state->mode.name, crtc->base.id, crtc->name,
160 : state);
161 : } else {
162 0 : state->enable = false;
163 0 : drm_dbg_atomic(crtc->dev,
164 : "Set [NOMODE] for [CRTC:%d:%s] state %p\n",
165 : crtc->base.id, crtc->name, state);
166 : }
167 :
168 : return 0;
169 : }
170 : EXPORT_SYMBOL(drm_atomic_set_mode_prop_for_crtc);
171 :
172 : /**
173 : * drm_atomic_set_crtc_for_plane - set CRTC for plane
174 : * @plane_state: the plane whose incoming state to update
175 : * @crtc: CRTC to use for the plane
176 : *
177 : * Changing the assigned CRTC for a plane requires us to grab the lock and state
178 : * for the new CRTC, as needed. This function takes care of all these details
179 : * besides updating the pointer in the state object itself.
180 : *
181 : * Returns:
182 : * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
183 : * then the w/w mutex code has detected a deadlock and the entire atomic
184 : * sequence must be restarted. All other errors are fatal.
185 : */
186 : int
187 0 : drm_atomic_set_crtc_for_plane(struct drm_plane_state *plane_state,
188 : struct drm_crtc *crtc)
189 : {
190 0 : struct drm_plane *plane = plane_state->plane;
191 : struct drm_crtc_state *crtc_state;
192 : /* Nothing to do for same crtc*/
193 0 : if (plane_state->crtc == crtc)
194 : return 0;
195 0 : if (plane_state->crtc) {
196 0 : crtc_state = drm_atomic_get_crtc_state(plane_state->state,
197 : plane_state->crtc);
198 0 : if (WARN_ON(IS_ERR(crtc_state)))
199 0 : return PTR_ERR(crtc_state);
200 :
201 0 : crtc_state->plane_mask &= ~drm_plane_mask(plane);
202 : }
203 :
204 0 : plane_state->crtc = crtc;
205 :
206 0 : if (crtc) {
207 0 : crtc_state = drm_atomic_get_crtc_state(plane_state->state,
208 : crtc);
209 0 : if (IS_ERR(crtc_state))
210 0 : return PTR_ERR(crtc_state);
211 0 : crtc_state->plane_mask |= drm_plane_mask(plane);
212 : }
213 :
214 0 : if (crtc)
215 0 : drm_dbg_atomic(plane->dev,
216 : "Link [PLANE:%d:%s] state %p to [CRTC:%d:%s]\n",
217 : plane->base.id, plane->name, plane_state,
218 : crtc->base.id, crtc->name);
219 : else
220 0 : drm_dbg_atomic(plane->dev,
221 : "Link [PLANE:%d:%s] state %p to [NOCRTC]\n",
222 : plane->base.id, plane->name, plane_state);
223 :
224 : return 0;
225 : }
226 : EXPORT_SYMBOL(drm_atomic_set_crtc_for_plane);
227 :
228 : /**
229 : * drm_atomic_set_fb_for_plane - set framebuffer for plane
230 : * @plane_state: atomic state object for the plane
231 : * @fb: fb to use for the plane
232 : *
233 : * Changing the assigned framebuffer for a plane requires us to grab a reference
234 : * to the new fb and drop the reference to the old fb, if there is one. This
235 : * function takes care of all these details besides updating the pointer in the
236 : * state object itself.
237 : */
238 : void
239 0 : drm_atomic_set_fb_for_plane(struct drm_plane_state *plane_state,
240 : struct drm_framebuffer *fb)
241 : {
242 0 : struct drm_plane *plane = plane_state->plane;
243 :
244 0 : if (fb)
245 0 : drm_dbg_atomic(plane->dev,
246 : "Set [FB:%d] for [PLANE:%d:%s] state %p\n",
247 : fb->base.id, plane->base.id, plane->name,
248 : plane_state);
249 : else
250 0 : drm_dbg_atomic(plane->dev,
251 : "Set [NOFB] for [PLANE:%d:%s] state %p\n",
252 : plane->base.id, plane->name, plane_state);
253 :
254 0 : drm_framebuffer_assign(&plane_state->fb, fb);
255 0 : }
256 : EXPORT_SYMBOL(drm_atomic_set_fb_for_plane);
257 :
258 : /**
259 : * drm_atomic_set_crtc_for_connector - set CRTC for connector
260 : * @conn_state: atomic state object for the connector
261 : * @crtc: CRTC to use for the connector
262 : *
263 : * Changing the assigned CRTC for a connector requires us to grab the lock and
264 : * state for the new CRTC, as needed. This function takes care of all these
265 : * details besides updating the pointer in the state object itself.
266 : *
267 : * Returns:
268 : * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
269 : * then the w/w mutex code has detected a deadlock and the entire atomic
270 : * sequence must be restarted. All other errors are fatal.
271 : */
272 : int
273 0 : drm_atomic_set_crtc_for_connector(struct drm_connector_state *conn_state,
274 : struct drm_crtc *crtc)
275 : {
276 0 : struct drm_connector *connector = conn_state->connector;
277 : struct drm_crtc_state *crtc_state;
278 :
279 0 : if (conn_state->crtc == crtc)
280 : return 0;
281 :
282 0 : if (conn_state->crtc) {
283 0 : crtc_state = drm_atomic_get_new_crtc_state(conn_state->state,
284 : conn_state->crtc);
285 :
286 0 : crtc_state->connector_mask &=
287 0 : ~drm_connector_mask(conn_state->connector);
288 :
289 0 : drm_connector_put(conn_state->connector);
290 0 : conn_state->crtc = NULL;
291 : }
292 :
293 0 : if (crtc) {
294 0 : crtc_state = drm_atomic_get_crtc_state(conn_state->state, crtc);
295 0 : if (IS_ERR(crtc_state))
296 0 : return PTR_ERR(crtc_state);
297 :
298 0 : crtc_state->connector_mask |=
299 0 : drm_connector_mask(conn_state->connector);
300 :
301 0 : drm_connector_get(conn_state->connector);
302 0 : conn_state->crtc = crtc;
303 :
304 0 : drm_dbg_atomic(connector->dev,
305 : "Link [CONNECTOR:%d:%s] state %p to [CRTC:%d:%s]\n",
306 : connector->base.id, connector->name,
307 : conn_state, crtc->base.id, crtc->name);
308 : } else {
309 0 : drm_dbg_atomic(connector->dev,
310 : "Link [CONNECTOR:%d:%s] state %p to [NOCRTC]\n",
311 : connector->base.id, connector->name,
312 : conn_state);
313 : }
314 :
315 : return 0;
316 : }
317 : EXPORT_SYMBOL(drm_atomic_set_crtc_for_connector);
318 :
319 : static void set_out_fence_for_crtc(struct drm_atomic_state *state,
320 : struct drm_crtc *crtc, s32 __user *fence_ptr)
321 : {
322 0 : state->crtcs[drm_crtc_index(crtc)].out_fence_ptr = fence_ptr;
323 : }
324 :
325 : static s32 __user *get_out_fence_for_crtc(struct drm_atomic_state *state,
326 : struct drm_crtc *crtc)
327 : {
328 : s32 __user *fence_ptr;
329 :
330 0 : fence_ptr = state->crtcs[drm_crtc_index(crtc)].out_fence_ptr;
331 0 : state->crtcs[drm_crtc_index(crtc)].out_fence_ptr = NULL;
332 :
333 : return fence_ptr;
334 : }
335 :
336 0 : static int set_out_fence_for_connector(struct drm_atomic_state *state,
337 : struct drm_connector *connector,
338 : s32 __user *fence_ptr)
339 : {
340 0 : unsigned int index = drm_connector_index(connector);
341 :
342 0 : if (!fence_ptr)
343 : return 0;
344 :
345 0 : if (put_user(-1, fence_ptr))
346 : return -EFAULT;
347 :
348 0 : state->connectors[index].out_fence_ptr = fence_ptr;
349 :
350 : return 0;
351 : }
352 :
353 : static s32 __user *get_out_fence_for_connector(struct drm_atomic_state *state,
354 : struct drm_connector *connector)
355 : {
356 0 : unsigned int index = drm_connector_index(connector);
357 : s32 __user *fence_ptr;
358 :
359 0 : fence_ptr = state->connectors[index].out_fence_ptr;
360 0 : state->connectors[index].out_fence_ptr = NULL;
361 :
362 : return fence_ptr;
363 : }
364 :
365 : static int
366 0 : drm_atomic_replace_property_blob_from_id(struct drm_device *dev,
367 : struct drm_property_blob **blob,
368 : uint64_t blob_id,
369 : ssize_t expected_size,
370 : ssize_t expected_elem_size,
371 : bool *replaced)
372 : {
373 0 : struct drm_property_blob *new_blob = NULL;
374 :
375 0 : if (blob_id != 0) {
376 0 : new_blob = drm_property_lookup_blob(dev, blob_id);
377 0 : if (new_blob == NULL) {
378 0 : drm_dbg_atomic(dev,
379 : "cannot find blob ID %llu\n", blob_id);
380 0 : return -EINVAL;
381 : }
382 :
383 0 : if (expected_size > 0 &&
384 0 : new_blob->length != expected_size) {
385 0 : drm_dbg_atomic(dev,
386 : "[BLOB:%d] length %zu different from expected %zu\n",
387 : new_blob->base.id, new_blob->length, expected_size);
388 0 : drm_property_blob_put(new_blob);
389 0 : return -EINVAL;
390 : }
391 0 : if (expected_elem_size > 0 &&
392 0 : new_blob->length % expected_elem_size != 0) {
393 0 : drm_dbg_atomic(dev,
394 : "[BLOB:%d] length %zu not divisible by element size %zu\n",
395 : new_blob->base.id, new_blob->length, expected_elem_size);
396 0 : drm_property_blob_put(new_blob);
397 0 : return -EINVAL;
398 : }
399 : }
400 :
401 0 : *replaced |= drm_property_replace_blob(blob, new_blob);
402 0 : drm_property_blob_put(new_blob);
403 :
404 0 : return 0;
405 : }
406 :
407 0 : static int drm_atomic_crtc_set_property(struct drm_crtc *crtc,
408 : struct drm_crtc_state *state, struct drm_property *property,
409 : uint64_t val)
410 : {
411 0 : struct drm_device *dev = crtc->dev;
412 0 : struct drm_mode_config *config = &dev->mode_config;
413 0 : bool replaced = false;
414 : int ret;
415 :
416 0 : if (property == config->prop_active)
417 0 : state->active = val;
418 0 : else if (property == config->prop_mode_id) {
419 0 : struct drm_property_blob *mode =
420 0 : drm_property_lookup_blob(dev, val);
421 0 : ret = drm_atomic_set_mode_prop_for_crtc(state, mode);
422 0 : drm_property_blob_put(mode);
423 0 : return ret;
424 0 : } else if (property == config->prop_vrr_enabled) {
425 0 : state->vrr_enabled = val;
426 0 : } else if (property == config->degamma_lut_property) {
427 0 : ret = drm_atomic_replace_property_blob_from_id(dev,
428 : &state->degamma_lut,
429 : val,
430 : -1, sizeof(struct drm_color_lut),
431 : &replaced);
432 0 : state->color_mgmt_changed |= replaced;
433 0 : return ret;
434 0 : } else if (property == config->ctm_property) {
435 0 : ret = drm_atomic_replace_property_blob_from_id(dev,
436 : &state->ctm,
437 : val,
438 : sizeof(struct drm_color_ctm), -1,
439 : &replaced);
440 0 : state->color_mgmt_changed |= replaced;
441 0 : return ret;
442 0 : } else if (property == config->gamma_lut_property) {
443 0 : ret = drm_atomic_replace_property_blob_from_id(dev,
444 : &state->gamma_lut,
445 : val,
446 : -1, sizeof(struct drm_color_lut),
447 : &replaced);
448 0 : state->color_mgmt_changed |= replaced;
449 0 : return ret;
450 0 : } else if (property == config->prop_out_fence_ptr) {
451 0 : s32 __user *fence_ptr = u64_to_user_ptr(val);
452 :
453 0 : if (!fence_ptr)
454 : return 0;
455 :
456 0 : if (put_user(-1, fence_ptr))
457 : return -EFAULT;
458 :
459 0 : set_out_fence_for_crtc(state->state, crtc, fence_ptr);
460 0 : } else if (property == crtc->scaling_filter_property) {
461 0 : state->scaling_filter = val;
462 0 : } else if (crtc->funcs->atomic_set_property) {
463 0 : return crtc->funcs->atomic_set_property(crtc, state, property, val);
464 : } else {
465 0 : drm_dbg_atomic(crtc->dev,
466 : "[CRTC:%d:%s] unknown property [PROP:%d:%s]\n",
467 : crtc->base.id, crtc->name,
468 : property->base.id, property->name);
469 0 : return -EINVAL;
470 : }
471 :
472 : return 0;
473 : }
474 :
475 : static int
476 0 : drm_atomic_crtc_get_property(struct drm_crtc *crtc,
477 : const struct drm_crtc_state *state,
478 : struct drm_property *property, uint64_t *val)
479 : {
480 0 : struct drm_device *dev = crtc->dev;
481 0 : struct drm_mode_config *config = &dev->mode_config;
482 :
483 0 : if (property == config->prop_active)
484 0 : *val = drm_atomic_crtc_effectively_active(state);
485 0 : else if (property == config->prop_mode_id)
486 0 : *val = (state->mode_blob) ? state->mode_blob->base.id : 0;
487 0 : else if (property == config->prop_vrr_enabled)
488 0 : *val = state->vrr_enabled;
489 0 : else if (property == config->degamma_lut_property)
490 0 : *val = (state->degamma_lut) ? state->degamma_lut->base.id : 0;
491 0 : else if (property == config->ctm_property)
492 0 : *val = (state->ctm) ? state->ctm->base.id : 0;
493 0 : else if (property == config->gamma_lut_property)
494 0 : *val = (state->gamma_lut) ? state->gamma_lut->base.id : 0;
495 0 : else if (property == config->prop_out_fence_ptr)
496 0 : *val = 0;
497 0 : else if (property == crtc->scaling_filter_property)
498 0 : *val = state->scaling_filter;
499 0 : else if (crtc->funcs->atomic_get_property)
500 0 : return crtc->funcs->atomic_get_property(crtc, state, property, val);
501 : else {
502 0 : drm_dbg_atomic(dev,
503 : "[CRTC:%d:%s] unknown property [PROP:%d:%s]\n",
504 : crtc->base.id, crtc->name,
505 : property->base.id, property->name);
506 0 : return -EINVAL;
507 : }
508 :
509 : return 0;
510 : }
511 :
512 0 : static int drm_atomic_plane_set_property(struct drm_plane *plane,
513 : struct drm_plane_state *state, struct drm_file *file_priv,
514 : struct drm_property *property, uint64_t val)
515 : {
516 0 : struct drm_device *dev = plane->dev;
517 0 : struct drm_mode_config *config = &dev->mode_config;
518 0 : bool replaced = false;
519 : int ret;
520 :
521 0 : if (property == config->prop_fb_id) {
522 : struct drm_framebuffer *fb;
523 :
524 0 : fb = drm_framebuffer_lookup(dev, file_priv, val);
525 0 : drm_atomic_set_fb_for_plane(state, fb);
526 0 : if (fb)
527 : drm_framebuffer_put(fb);
528 0 : } else if (property == config->prop_in_fence_fd) {
529 0 : if (state->fence)
530 : return -EINVAL;
531 :
532 0 : if (U642I64(val) == -1)
533 : return 0;
534 :
535 0 : state->fence = sync_file_get_fence(val);
536 0 : if (!state->fence)
537 : return -EINVAL;
538 :
539 0 : } else if (property == config->prop_crtc_id) {
540 0 : struct drm_crtc *crtc = drm_crtc_find(dev, file_priv, val);
541 :
542 0 : if (val && !crtc) {
543 0 : drm_dbg_atomic(dev,
544 : "[PROP:%d:%s] cannot find CRTC with ID %llu\n",
545 : property->base.id, property->name, val);
546 0 : return -EACCES;
547 : }
548 0 : return drm_atomic_set_crtc_for_plane(state, crtc);
549 0 : } else if (property == config->prop_crtc_x) {
550 0 : state->crtc_x = U642I64(val);
551 0 : } else if (property == config->prop_crtc_y) {
552 0 : state->crtc_y = U642I64(val);
553 0 : } else if (property == config->prop_crtc_w) {
554 0 : state->crtc_w = val;
555 0 : } else if (property == config->prop_crtc_h) {
556 0 : state->crtc_h = val;
557 0 : } else if (property == config->prop_src_x) {
558 0 : state->src_x = val;
559 0 : } else if (property == config->prop_src_y) {
560 0 : state->src_y = val;
561 0 : } else if (property == config->prop_src_w) {
562 0 : state->src_w = val;
563 0 : } else if (property == config->prop_src_h) {
564 0 : state->src_h = val;
565 0 : } else if (property == plane->alpha_property) {
566 0 : state->alpha = val;
567 0 : } else if (property == plane->blend_mode_property) {
568 0 : state->pixel_blend_mode = val;
569 0 : } else if (property == plane->rotation_property) {
570 0 : if (!is_power_of_2(val & DRM_MODE_ROTATE_MASK)) {
571 0 : drm_dbg_atomic(plane->dev,
572 : "[PLANE:%d:%s] bad rotation bitmask: 0x%llx\n",
573 : plane->base.id, plane->name, val);
574 0 : return -EINVAL;
575 : }
576 0 : state->rotation = val;
577 0 : } else if (property == plane->zpos_property) {
578 0 : state->zpos = val;
579 0 : } else if (property == plane->color_encoding_property) {
580 0 : state->color_encoding = val;
581 0 : } else if (property == plane->color_range_property) {
582 0 : state->color_range = val;
583 0 : } else if (property == config->prop_fb_damage_clips) {
584 0 : ret = drm_atomic_replace_property_blob_from_id(dev,
585 : &state->fb_damage_clips,
586 : val,
587 : -1,
588 : sizeof(struct drm_rect),
589 : &replaced);
590 0 : return ret;
591 0 : } else if (property == plane->scaling_filter_property) {
592 0 : state->scaling_filter = val;
593 0 : } else if (plane->funcs->atomic_set_property) {
594 0 : return plane->funcs->atomic_set_property(plane, state,
595 : property, val);
596 : } else {
597 0 : drm_dbg_atomic(plane->dev,
598 : "[PLANE:%d:%s] unknown property [PROP:%d:%s]\n",
599 : plane->base.id, plane->name,
600 : property->base.id, property->name);
601 0 : return -EINVAL;
602 : }
603 :
604 : return 0;
605 : }
606 :
607 : static int
608 0 : drm_atomic_plane_get_property(struct drm_plane *plane,
609 : const struct drm_plane_state *state,
610 : struct drm_property *property, uint64_t *val)
611 : {
612 0 : struct drm_device *dev = plane->dev;
613 0 : struct drm_mode_config *config = &dev->mode_config;
614 :
615 0 : if (property == config->prop_fb_id) {
616 0 : *val = (state->fb) ? state->fb->base.id : 0;
617 0 : } else if (property == config->prop_in_fence_fd) {
618 0 : *val = -1;
619 0 : } else if (property == config->prop_crtc_id) {
620 0 : *val = (state->crtc) ? state->crtc->base.id : 0;
621 0 : } else if (property == config->prop_crtc_x) {
622 0 : *val = I642U64(state->crtc_x);
623 0 : } else if (property == config->prop_crtc_y) {
624 0 : *val = I642U64(state->crtc_y);
625 0 : } else if (property == config->prop_crtc_w) {
626 0 : *val = state->crtc_w;
627 0 : } else if (property == config->prop_crtc_h) {
628 0 : *val = state->crtc_h;
629 0 : } else if (property == config->prop_src_x) {
630 0 : *val = state->src_x;
631 0 : } else if (property == config->prop_src_y) {
632 0 : *val = state->src_y;
633 0 : } else if (property == config->prop_src_w) {
634 0 : *val = state->src_w;
635 0 : } else if (property == config->prop_src_h) {
636 0 : *val = state->src_h;
637 0 : } else if (property == plane->alpha_property) {
638 0 : *val = state->alpha;
639 0 : } else if (property == plane->blend_mode_property) {
640 0 : *val = state->pixel_blend_mode;
641 0 : } else if (property == plane->rotation_property) {
642 0 : *val = state->rotation;
643 0 : } else if (property == plane->zpos_property) {
644 0 : *val = state->zpos;
645 0 : } else if (property == plane->color_encoding_property) {
646 0 : *val = state->color_encoding;
647 0 : } else if (property == plane->color_range_property) {
648 0 : *val = state->color_range;
649 0 : } else if (property == config->prop_fb_damage_clips) {
650 0 : *val = (state->fb_damage_clips) ?
651 0 : state->fb_damage_clips->base.id : 0;
652 0 : } else if (property == plane->scaling_filter_property) {
653 0 : *val = state->scaling_filter;
654 0 : } else if (plane->funcs->atomic_get_property) {
655 0 : return plane->funcs->atomic_get_property(plane, state, property, val);
656 : } else {
657 0 : drm_dbg_atomic(dev,
658 : "[PLANE:%d:%s] unknown property [PROP:%d:%s]\n",
659 : plane->base.id, plane->name,
660 : property->base.id, property->name);
661 0 : return -EINVAL;
662 : }
663 :
664 : return 0;
665 : }
666 :
667 0 : static int drm_atomic_set_writeback_fb_for_connector(
668 : struct drm_connector_state *conn_state,
669 : struct drm_framebuffer *fb)
670 : {
671 : int ret;
672 0 : struct drm_connector *conn = conn_state->connector;
673 :
674 0 : ret = drm_writeback_set_fb(conn_state, fb);
675 0 : if (ret < 0)
676 : return ret;
677 :
678 0 : if (fb)
679 0 : drm_dbg_atomic(conn->dev,
680 : "Set [FB:%d] for connector state %p\n",
681 : fb->base.id, conn_state);
682 : else
683 0 : drm_dbg_atomic(conn->dev,
684 : "Set [NOFB] for connector state %p\n",
685 : conn_state);
686 :
687 : return 0;
688 : }
689 :
690 0 : static int drm_atomic_connector_set_property(struct drm_connector *connector,
691 : struct drm_connector_state *state, struct drm_file *file_priv,
692 : struct drm_property *property, uint64_t val)
693 : {
694 0 : struct drm_device *dev = connector->dev;
695 0 : struct drm_mode_config *config = &dev->mode_config;
696 0 : bool replaced = false;
697 : int ret;
698 :
699 0 : if (property == config->prop_crtc_id) {
700 0 : struct drm_crtc *crtc = drm_crtc_find(dev, file_priv, val);
701 :
702 0 : if (val && !crtc) {
703 0 : drm_dbg_atomic(dev,
704 : "[PROP:%d:%s] cannot find CRTC with ID %llu\n",
705 : property->base.id, property->name, val);
706 0 : return -EACCES;
707 : }
708 0 : return drm_atomic_set_crtc_for_connector(state, crtc);
709 0 : } else if (property == config->dpms_property) {
710 : /* setting DPMS property requires special handling, which
711 : * is done in legacy setprop path for us. Disallow (for
712 : * now?) atomic writes to DPMS property:
713 : */
714 0 : drm_dbg_atomic(dev,
715 : "legacy [PROP:%d:%s] can only be set via legacy uAPI\n",
716 : property->base.id, property->name);
717 0 : return -EINVAL;
718 0 : } else if (property == config->tv_select_subconnector_property) {
719 0 : state->tv.select_subconnector = val;
720 0 : } else if (property == config->tv_subconnector_property) {
721 0 : state->tv.subconnector = val;
722 0 : } else if (property == config->tv_left_margin_property) {
723 0 : state->tv.margins.left = val;
724 0 : } else if (property == config->tv_right_margin_property) {
725 0 : state->tv.margins.right = val;
726 0 : } else if (property == config->tv_top_margin_property) {
727 0 : state->tv.margins.top = val;
728 0 : } else if (property == config->tv_bottom_margin_property) {
729 0 : state->tv.margins.bottom = val;
730 0 : } else if (property == config->legacy_tv_mode_property) {
731 0 : state->tv.legacy_mode = val;
732 0 : } else if (property == config->tv_mode_property) {
733 0 : state->tv.mode = val;
734 0 : } else if (property == config->tv_brightness_property) {
735 0 : state->tv.brightness = val;
736 0 : } else if (property == config->tv_contrast_property) {
737 0 : state->tv.contrast = val;
738 0 : } else if (property == config->tv_flicker_reduction_property) {
739 0 : state->tv.flicker_reduction = val;
740 0 : } else if (property == config->tv_overscan_property) {
741 0 : state->tv.overscan = val;
742 0 : } else if (property == config->tv_saturation_property) {
743 0 : state->tv.saturation = val;
744 0 : } else if (property == config->tv_hue_property) {
745 0 : state->tv.hue = val;
746 0 : } else if (property == config->link_status_property) {
747 : /* Never downgrade from GOOD to BAD on userspace's request here,
748 : * only hw issues can do that.
749 : *
750 : * For an atomic property the userspace doesn't need to be able
751 : * to understand all the properties, but needs to be able to
752 : * restore the state it wants on VT switch. So if the userspace
753 : * tries to change the link_status from GOOD to BAD, driver
754 : * silently rejects it and returns a 0. This prevents userspace
755 : * from accidentally breaking the display when it restores the
756 : * state.
757 : */
758 0 : if (state->link_status != DRM_LINK_STATUS_GOOD)
759 0 : state->link_status = val;
760 0 : } else if (property == config->hdr_output_metadata_property) {
761 0 : ret = drm_atomic_replace_property_blob_from_id(dev,
762 : &state->hdr_output_metadata,
763 : val,
764 : sizeof(struct hdr_output_metadata), -1,
765 : &replaced);
766 0 : return ret;
767 0 : } else if (property == config->aspect_ratio_property) {
768 0 : state->picture_aspect_ratio = val;
769 0 : } else if (property == config->content_type_property) {
770 0 : state->content_type = val;
771 0 : } else if (property == connector->scaling_mode_property) {
772 0 : state->scaling_mode = val;
773 0 : } else if (property == config->content_protection_property) {
774 0 : if (val == DRM_MODE_CONTENT_PROTECTION_ENABLED) {
775 0 : drm_dbg_kms(dev, "only drivers can set CP Enabled\n");
776 0 : return -EINVAL;
777 : }
778 0 : state->content_protection = val;
779 0 : } else if (property == config->hdcp_content_type_property) {
780 0 : state->hdcp_content_type = val;
781 0 : } else if (property == connector->colorspace_property) {
782 0 : state->colorspace = val;
783 0 : } else if (property == config->writeback_fb_id_property) {
784 : struct drm_framebuffer *fb;
785 : int ret;
786 :
787 0 : fb = drm_framebuffer_lookup(dev, file_priv, val);
788 0 : ret = drm_atomic_set_writeback_fb_for_connector(state, fb);
789 0 : if (fb)
790 : drm_framebuffer_put(fb);
791 : return ret;
792 0 : } else if (property == config->writeback_out_fence_ptr_property) {
793 0 : s32 __user *fence_ptr = u64_to_user_ptr(val);
794 :
795 0 : return set_out_fence_for_connector(state->state, connector,
796 : fence_ptr);
797 0 : } else if (property == connector->max_bpc_property) {
798 0 : state->max_requested_bpc = val;
799 0 : } else if (property == connector->privacy_screen_sw_state_property) {
800 0 : state->privacy_screen_sw_state = val;
801 0 : } else if (connector->funcs->atomic_set_property) {
802 0 : return connector->funcs->atomic_set_property(connector,
803 : state, property, val);
804 : } else {
805 0 : drm_dbg_atomic(connector->dev,
806 : "[CONNECTOR:%d:%s] unknown property [PROP:%d:%s]\n",
807 : connector->base.id, connector->name,
808 : property->base.id, property->name);
809 0 : return -EINVAL;
810 : }
811 :
812 : return 0;
813 : }
814 :
815 : static int
816 0 : drm_atomic_connector_get_property(struct drm_connector *connector,
817 : const struct drm_connector_state *state,
818 : struct drm_property *property, uint64_t *val)
819 : {
820 0 : struct drm_device *dev = connector->dev;
821 0 : struct drm_mode_config *config = &dev->mode_config;
822 :
823 0 : if (property == config->prop_crtc_id) {
824 0 : *val = (state->crtc) ? state->crtc->base.id : 0;
825 0 : } else if (property == config->dpms_property) {
826 0 : if (state->crtc && state->crtc->state->self_refresh_active)
827 0 : *val = DRM_MODE_DPMS_ON;
828 : else
829 0 : *val = connector->dpms;
830 0 : } else if (property == config->tv_select_subconnector_property) {
831 0 : *val = state->tv.select_subconnector;
832 0 : } else if (property == config->tv_subconnector_property) {
833 0 : *val = state->tv.subconnector;
834 0 : } else if (property == config->tv_left_margin_property) {
835 0 : *val = state->tv.margins.left;
836 0 : } else if (property == config->tv_right_margin_property) {
837 0 : *val = state->tv.margins.right;
838 0 : } else if (property == config->tv_top_margin_property) {
839 0 : *val = state->tv.margins.top;
840 0 : } else if (property == config->tv_bottom_margin_property) {
841 0 : *val = state->tv.margins.bottom;
842 0 : } else if (property == config->legacy_tv_mode_property) {
843 0 : *val = state->tv.legacy_mode;
844 0 : } else if (property == config->tv_mode_property) {
845 0 : *val = state->tv.mode;
846 0 : } else if (property == config->tv_brightness_property) {
847 0 : *val = state->tv.brightness;
848 0 : } else if (property == config->tv_contrast_property) {
849 0 : *val = state->tv.contrast;
850 0 : } else if (property == config->tv_flicker_reduction_property) {
851 0 : *val = state->tv.flicker_reduction;
852 0 : } else if (property == config->tv_overscan_property) {
853 0 : *val = state->tv.overscan;
854 0 : } else if (property == config->tv_saturation_property) {
855 0 : *val = state->tv.saturation;
856 0 : } else if (property == config->tv_hue_property) {
857 0 : *val = state->tv.hue;
858 0 : } else if (property == config->link_status_property) {
859 0 : *val = state->link_status;
860 0 : } else if (property == config->aspect_ratio_property) {
861 0 : *val = state->picture_aspect_ratio;
862 0 : } else if (property == config->content_type_property) {
863 0 : *val = state->content_type;
864 0 : } else if (property == connector->colorspace_property) {
865 0 : *val = state->colorspace;
866 0 : } else if (property == connector->scaling_mode_property) {
867 0 : *val = state->scaling_mode;
868 0 : } else if (property == config->hdr_output_metadata_property) {
869 0 : *val = state->hdr_output_metadata ?
870 0 : state->hdr_output_metadata->base.id : 0;
871 0 : } else if (property == config->content_protection_property) {
872 0 : *val = state->content_protection;
873 0 : } else if (property == config->hdcp_content_type_property) {
874 0 : *val = state->hdcp_content_type;
875 0 : } else if (property == config->writeback_fb_id_property) {
876 : /* Writeback framebuffer is one-shot, write and forget */
877 0 : *val = 0;
878 0 : } else if (property == config->writeback_out_fence_ptr_property) {
879 0 : *val = 0;
880 0 : } else if (property == connector->max_bpc_property) {
881 0 : *val = state->max_requested_bpc;
882 0 : } else if (property == connector->privacy_screen_sw_state_property) {
883 0 : *val = state->privacy_screen_sw_state;
884 0 : } else if (connector->funcs->atomic_get_property) {
885 0 : return connector->funcs->atomic_get_property(connector,
886 : state, property, val);
887 : } else {
888 0 : drm_dbg_atomic(dev,
889 : "[CONNECTOR:%d:%s] unknown property [PROP:%d:%s]\n",
890 : connector->base.id, connector->name,
891 : property->base.id, property->name);
892 0 : return -EINVAL;
893 : }
894 :
895 : return 0;
896 : }
897 :
898 0 : int drm_atomic_get_property(struct drm_mode_object *obj,
899 : struct drm_property *property, uint64_t *val)
900 : {
901 0 : struct drm_device *dev = property->dev;
902 : int ret;
903 :
904 0 : switch (obj->type) {
905 : case DRM_MODE_OBJECT_CONNECTOR: {
906 0 : struct drm_connector *connector = obj_to_connector(obj);
907 :
908 0 : WARN_ON(!drm_modeset_is_locked(&dev->mode_config.connection_mutex));
909 0 : ret = drm_atomic_connector_get_property(connector,
910 0 : connector->state, property, val);
911 0 : break;
912 : }
913 : case DRM_MODE_OBJECT_CRTC: {
914 0 : struct drm_crtc *crtc = obj_to_crtc(obj);
915 :
916 0 : WARN_ON(!drm_modeset_is_locked(&crtc->mutex));
917 0 : ret = drm_atomic_crtc_get_property(crtc,
918 0 : crtc->state, property, val);
919 0 : break;
920 : }
921 : case DRM_MODE_OBJECT_PLANE: {
922 0 : struct drm_plane *plane = obj_to_plane(obj);
923 :
924 0 : WARN_ON(!drm_modeset_is_locked(&plane->mutex));
925 0 : ret = drm_atomic_plane_get_property(plane,
926 0 : plane->state, property, val);
927 0 : break;
928 : }
929 : default:
930 0 : drm_dbg_atomic(dev, "[OBJECT:%d] has no properties\n", obj->id);
931 0 : ret = -EINVAL;
932 0 : break;
933 : }
934 :
935 0 : return ret;
936 : }
937 :
938 : /*
939 : * The big monster ioctl
940 : */
941 :
942 0 : static struct drm_pending_vblank_event *create_vblank_event(
943 : struct drm_crtc *crtc, uint64_t user_data)
944 : {
945 0 : struct drm_pending_vblank_event *e = NULL;
946 :
947 0 : e = kzalloc(sizeof *e, GFP_KERNEL);
948 0 : if (!e)
949 : return NULL;
950 :
951 0 : e->event.base.type = DRM_EVENT_FLIP_COMPLETE;
952 0 : e->event.base.length = sizeof(e->event);
953 0 : e->event.vbl.crtc_id = crtc->base.id;
954 0 : e->event.vbl.user_data = user_data;
955 :
956 : return e;
957 : }
958 :
959 0 : int drm_atomic_connector_commit_dpms(struct drm_atomic_state *state,
960 : struct drm_connector *connector,
961 : int mode)
962 : {
963 : struct drm_connector *tmp_connector;
964 : struct drm_connector_state *new_conn_state;
965 : struct drm_crtc *crtc;
966 : struct drm_crtc_state *crtc_state;
967 0 : int i, ret, old_mode = connector->dpms;
968 0 : bool active = false;
969 :
970 0 : ret = drm_modeset_lock(&state->dev->mode_config.connection_mutex,
971 : state->acquire_ctx);
972 0 : if (ret)
973 : return ret;
974 :
975 0 : if (mode != DRM_MODE_DPMS_ON)
976 0 : mode = DRM_MODE_DPMS_OFF;
977 0 : connector->dpms = mode;
978 :
979 0 : crtc = connector->state->crtc;
980 0 : if (!crtc)
981 : goto out;
982 0 : ret = drm_atomic_add_affected_connectors(state, crtc);
983 0 : if (ret)
984 : goto out;
985 :
986 0 : crtc_state = drm_atomic_get_crtc_state(state, crtc);
987 0 : if (IS_ERR(crtc_state)) {
988 0 : ret = PTR_ERR(crtc_state);
989 0 : goto out;
990 : }
991 :
992 0 : for_each_new_connector_in_state(state, tmp_connector, new_conn_state, i) {
993 0 : if (new_conn_state->crtc != crtc)
994 0 : continue;
995 0 : if (tmp_connector->dpms == DRM_MODE_DPMS_ON) {
996 : active = true;
997 : break;
998 : }
999 : }
1000 :
1001 0 : crtc_state->active = active;
1002 0 : ret = drm_atomic_commit(state);
1003 : out:
1004 0 : if (ret != 0)
1005 0 : connector->dpms = old_mode;
1006 : return ret;
1007 : }
1008 :
1009 0 : int drm_atomic_set_property(struct drm_atomic_state *state,
1010 : struct drm_file *file_priv,
1011 : struct drm_mode_object *obj,
1012 : struct drm_property *prop,
1013 : uint64_t prop_value)
1014 : {
1015 : struct drm_mode_object *ref;
1016 : int ret;
1017 :
1018 0 : if (!drm_property_change_valid_get(prop, prop_value, &ref))
1019 : return -EINVAL;
1020 :
1021 0 : switch (obj->type) {
1022 : case DRM_MODE_OBJECT_CONNECTOR: {
1023 0 : struct drm_connector *connector = obj_to_connector(obj);
1024 : struct drm_connector_state *connector_state;
1025 :
1026 0 : connector_state = drm_atomic_get_connector_state(state, connector);
1027 0 : if (IS_ERR(connector_state)) {
1028 0 : ret = PTR_ERR(connector_state);
1029 0 : break;
1030 : }
1031 :
1032 0 : ret = drm_atomic_connector_set_property(connector,
1033 : connector_state, file_priv,
1034 : prop, prop_value);
1035 0 : break;
1036 : }
1037 : case DRM_MODE_OBJECT_CRTC: {
1038 0 : struct drm_crtc *crtc = obj_to_crtc(obj);
1039 : struct drm_crtc_state *crtc_state;
1040 :
1041 0 : crtc_state = drm_atomic_get_crtc_state(state, crtc);
1042 0 : if (IS_ERR(crtc_state)) {
1043 0 : ret = PTR_ERR(crtc_state);
1044 0 : break;
1045 : }
1046 :
1047 0 : ret = drm_atomic_crtc_set_property(crtc,
1048 : crtc_state, prop, prop_value);
1049 0 : break;
1050 : }
1051 : case DRM_MODE_OBJECT_PLANE: {
1052 0 : struct drm_plane *plane = obj_to_plane(obj);
1053 : struct drm_plane_state *plane_state;
1054 :
1055 0 : plane_state = drm_atomic_get_plane_state(state, plane);
1056 0 : if (IS_ERR(plane_state)) {
1057 0 : ret = PTR_ERR(plane_state);
1058 0 : break;
1059 : }
1060 :
1061 0 : ret = drm_atomic_plane_set_property(plane,
1062 : plane_state, file_priv,
1063 : prop, prop_value);
1064 0 : break;
1065 : }
1066 : default:
1067 0 : drm_dbg_atomic(prop->dev, "[OBJECT:%d] has no properties\n", obj->id);
1068 0 : ret = -EINVAL;
1069 0 : break;
1070 : }
1071 :
1072 0 : drm_property_change_valid_put(prop, ref);
1073 0 : return ret;
1074 : }
1075 :
1076 : /**
1077 : * DOC: explicit fencing properties
1078 : *
1079 : * Explicit fencing allows userspace to control the buffer synchronization
1080 : * between devices. A Fence or a group of fences are transferred to/from
1081 : * userspace using Sync File fds and there are two DRM properties for that.
1082 : * IN_FENCE_FD on each DRM Plane to send fences to the kernel and
1083 : * OUT_FENCE_PTR on each DRM CRTC to receive fences from the kernel.
1084 : *
1085 : * As a contrast, with implicit fencing the kernel keeps track of any
1086 : * ongoing rendering, and automatically ensures that the atomic update waits
1087 : * for any pending rendering to complete. This is usually tracked in &struct
1088 : * dma_resv which can also contain mandatory kernel fences. Implicit syncing
1089 : * is how Linux traditionally worked (e.g. DRI2/3 on X.org), whereas explicit
1090 : * fencing is what Android wants.
1091 : *
1092 : * "IN_FENCE_FD”:
1093 : * Use this property to pass a fence that DRM should wait on before
1094 : * proceeding with the Atomic Commit request and show the framebuffer for
1095 : * the plane on the screen. The fence can be either a normal fence or a
1096 : * merged one, the sync_file framework will handle both cases and use a
1097 : * fence_array if a merged fence is received. Passing -1 here means no
1098 : * fences to wait on.
1099 : *
1100 : * If the Atomic Commit request has the DRM_MODE_ATOMIC_TEST_ONLY flag
1101 : * it will only check if the Sync File is a valid one.
1102 : *
1103 : * On the driver side the fence is stored on the @fence parameter of
1104 : * &struct drm_plane_state. Drivers which also support implicit fencing
1105 : * should extract the implicit fence using drm_gem_plane_helper_prepare_fb(),
1106 : * to make sure there's consistent behaviour between drivers in precedence
1107 : * of implicit vs. explicit fencing.
1108 : *
1109 : * "OUT_FENCE_PTR”:
1110 : * Use this property to pass a file descriptor pointer to DRM. Once the
1111 : * Atomic Commit request call returns OUT_FENCE_PTR will be filled with
1112 : * the file descriptor number of a Sync File. This Sync File contains the
1113 : * CRTC fence that will be signaled when all framebuffers present on the
1114 : * Atomic Commit * request for that given CRTC are scanned out on the
1115 : * screen.
1116 : *
1117 : * The Atomic Commit request fails if a invalid pointer is passed. If the
1118 : * Atomic Commit request fails for any other reason the out fence fd
1119 : * returned will be -1. On a Atomic Commit with the
1120 : * DRM_MODE_ATOMIC_TEST_ONLY flag the out fence will also be set to -1.
1121 : *
1122 : * Note that out-fences don't have a special interface to drivers and are
1123 : * internally represented by a &struct drm_pending_vblank_event in struct
1124 : * &drm_crtc_state, which is also used by the nonblocking atomic commit
1125 : * helpers and for the DRM event handling for existing userspace.
1126 : */
1127 :
1128 : struct drm_out_fence_state {
1129 : s32 __user *out_fence_ptr;
1130 : struct sync_file *sync_file;
1131 : int fd;
1132 : };
1133 :
1134 0 : static int setup_out_fence(struct drm_out_fence_state *fence_state,
1135 : struct dma_fence *fence)
1136 : {
1137 0 : fence_state->fd = get_unused_fd_flags(O_CLOEXEC);
1138 0 : if (fence_state->fd < 0)
1139 : return fence_state->fd;
1140 :
1141 0 : if (put_user(fence_state->fd, fence_state->out_fence_ptr))
1142 : return -EFAULT;
1143 :
1144 0 : fence_state->sync_file = sync_file_create(fence);
1145 0 : if (!fence_state->sync_file)
1146 : return -ENOMEM;
1147 :
1148 0 : return 0;
1149 : }
1150 :
1151 0 : static int prepare_signaling(struct drm_device *dev,
1152 : struct drm_atomic_state *state,
1153 : struct drm_mode_atomic *arg,
1154 : struct drm_file *file_priv,
1155 : struct drm_out_fence_state **fence_state,
1156 : unsigned int *num_fences)
1157 : {
1158 : struct drm_crtc *crtc;
1159 : struct drm_crtc_state *crtc_state;
1160 : struct drm_connector *conn;
1161 : struct drm_connector_state *conn_state;
1162 0 : int i, c = 0, ret;
1163 :
1164 0 : if (arg->flags & DRM_MODE_ATOMIC_TEST_ONLY)
1165 : return 0;
1166 :
1167 0 : for_each_new_crtc_in_state(state, crtc, crtc_state, i) {
1168 : s32 __user *fence_ptr;
1169 :
1170 0 : fence_ptr = get_out_fence_for_crtc(crtc_state->state, crtc);
1171 :
1172 0 : if (arg->flags & DRM_MODE_PAGE_FLIP_EVENT || fence_ptr) {
1173 : struct drm_pending_vblank_event *e;
1174 :
1175 0 : e = create_vblank_event(crtc, arg->user_data);
1176 0 : if (!e)
1177 : return -ENOMEM;
1178 :
1179 0 : crtc_state->event = e;
1180 : }
1181 :
1182 0 : if (arg->flags & DRM_MODE_PAGE_FLIP_EVENT) {
1183 0 : struct drm_pending_vblank_event *e = crtc_state->event;
1184 :
1185 0 : if (!file_priv)
1186 0 : continue;
1187 :
1188 0 : ret = drm_event_reserve_init(dev, file_priv, &e->base,
1189 : &e->event.base);
1190 0 : if (ret) {
1191 0 : kfree(e);
1192 0 : crtc_state->event = NULL;
1193 : return ret;
1194 : }
1195 : }
1196 :
1197 0 : if (fence_ptr) {
1198 : struct dma_fence *fence;
1199 : struct drm_out_fence_state *f;
1200 :
1201 0 : f = krealloc(*fence_state, sizeof(**fence_state) *
1202 0 : (*num_fences + 1), GFP_KERNEL);
1203 0 : if (!f)
1204 : return -ENOMEM;
1205 :
1206 0 : memset(&f[*num_fences], 0, sizeof(*f));
1207 :
1208 0 : f[*num_fences].out_fence_ptr = fence_ptr;
1209 0 : *fence_state = f;
1210 :
1211 0 : fence = drm_crtc_create_fence(crtc);
1212 0 : if (!fence)
1213 : return -ENOMEM;
1214 :
1215 0 : ret = setup_out_fence(&f[(*num_fences)++], fence);
1216 0 : if (ret) {
1217 0 : dma_fence_put(fence);
1218 : return ret;
1219 : }
1220 :
1221 0 : crtc_state->event->base.fence = fence;
1222 : }
1223 :
1224 0 : c++;
1225 : }
1226 :
1227 0 : for_each_new_connector_in_state(state, conn, conn_state, i) {
1228 : struct drm_writeback_connector *wb_conn;
1229 : struct drm_out_fence_state *f;
1230 : struct dma_fence *fence;
1231 : s32 __user *fence_ptr;
1232 :
1233 0 : if (!conn_state->writeback_job)
1234 0 : continue;
1235 :
1236 0 : fence_ptr = get_out_fence_for_connector(state, conn);
1237 0 : if (!fence_ptr)
1238 0 : continue;
1239 :
1240 0 : f = krealloc(*fence_state, sizeof(**fence_state) *
1241 0 : (*num_fences + 1), GFP_KERNEL);
1242 0 : if (!f)
1243 : return -ENOMEM;
1244 :
1245 0 : memset(&f[*num_fences], 0, sizeof(*f));
1246 :
1247 0 : f[*num_fences].out_fence_ptr = fence_ptr;
1248 0 : *fence_state = f;
1249 :
1250 0 : wb_conn = drm_connector_to_writeback(conn);
1251 0 : fence = drm_writeback_get_out_fence(wb_conn);
1252 0 : if (!fence)
1253 : return -ENOMEM;
1254 :
1255 0 : ret = setup_out_fence(&f[(*num_fences)++], fence);
1256 0 : if (ret) {
1257 0 : dma_fence_put(fence);
1258 : return ret;
1259 : }
1260 :
1261 0 : conn_state->writeback_job->out_fence = fence;
1262 : }
1263 :
1264 : /*
1265 : * Having this flag means user mode pends on event which will never
1266 : * reach due to lack of at least one CRTC for signaling
1267 : */
1268 0 : if (c == 0 && (arg->flags & DRM_MODE_PAGE_FLIP_EVENT)) {
1269 0 : drm_dbg_atomic(dev, "need at least one CRTC for DRM_MODE_PAGE_FLIP_EVENT");
1270 : return -EINVAL;
1271 : }
1272 :
1273 : return 0;
1274 : }
1275 :
1276 0 : static void complete_signaling(struct drm_device *dev,
1277 : struct drm_atomic_state *state,
1278 : struct drm_out_fence_state *fence_state,
1279 : unsigned int num_fences,
1280 : bool install_fds)
1281 : {
1282 : struct drm_crtc *crtc;
1283 : struct drm_crtc_state *crtc_state;
1284 : int i;
1285 :
1286 0 : if (install_fds) {
1287 0 : for (i = 0; i < num_fences; i++)
1288 0 : fd_install(fence_state[i].fd,
1289 0 : fence_state[i].sync_file->file);
1290 :
1291 0 : kfree(fence_state);
1292 0 : return;
1293 : }
1294 :
1295 0 : for_each_new_crtc_in_state(state, crtc, crtc_state, i) {
1296 0 : struct drm_pending_vblank_event *event = crtc_state->event;
1297 : /*
1298 : * Free the allocated event. drm_atomic_helper_setup_commit
1299 : * can allocate an event too, so only free it if it's ours
1300 : * to prevent a double free in drm_atomic_state_clear.
1301 : */
1302 0 : if (event && (event->base.fence || event->base.file_priv)) {
1303 0 : drm_event_cancel_free(dev, &event->base);
1304 0 : crtc_state->event = NULL;
1305 : }
1306 : }
1307 :
1308 0 : if (!fence_state)
1309 : return;
1310 :
1311 0 : for (i = 0; i < num_fences; i++) {
1312 0 : if (fence_state[i].sync_file)
1313 0 : fput(fence_state[i].sync_file->file);
1314 0 : if (fence_state[i].fd >= 0)
1315 0 : put_unused_fd(fence_state[i].fd);
1316 :
1317 : /* If this fails log error to the user */
1318 0 : if (fence_state[i].out_fence_ptr &&
1319 0 : put_user(-1, fence_state[i].out_fence_ptr))
1320 0 : drm_dbg_atomic(dev, "Couldn't clear out_fence_ptr\n");
1321 : }
1322 :
1323 0 : kfree(fence_state);
1324 : }
1325 :
1326 0 : int drm_mode_atomic_ioctl(struct drm_device *dev,
1327 : void *data, struct drm_file *file_priv)
1328 : {
1329 0 : struct drm_mode_atomic *arg = data;
1330 0 : uint32_t __user *objs_ptr = (uint32_t __user *)(unsigned long)(arg->objs_ptr);
1331 0 : uint32_t __user *count_props_ptr = (uint32_t __user *)(unsigned long)(arg->count_props_ptr);
1332 0 : uint32_t __user *props_ptr = (uint32_t __user *)(unsigned long)(arg->props_ptr);
1333 0 : uint64_t __user *prop_values_ptr = (uint64_t __user *)(unsigned long)(arg->prop_values_ptr);
1334 : unsigned int copied_objs, copied_props;
1335 : struct drm_atomic_state *state;
1336 : struct drm_modeset_acquire_ctx ctx;
1337 : struct drm_out_fence_state *fence_state;
1338 0 : int ret = 0;
1339 : unsigned int i, j, num_fences;
1340 :
1341 : /* disallow for drivers not supporting atomic: */
1342 0 : if (!drm_core_check_feature(dev, DRIVER_ATOMIC))
1343 : return -EOPNOTSUPP;
1344 :
1345 : /* disallow for userspace that has not enabled atomic cap (even
1346 : * though this may be a bit overkill, since legacy userspace
1347 : * wouldn't know how to call this ioctl)
1348 : */
1349 0 : if (!file_priv->atomic) {
1350 0 : drm_dbg_atomic(dev,
1351 : "commit failed: atomic cap not enabled\n");
1352 0 : return -EINVAL;
1353 : }
1354 :
1355 0 : if (arg->flags & ~DRM_MODE_ATOMIC_FLAGS) {
1356 0 : drm_dbg_atomic(dev, "commit failed: invalid flag\n");
1357 0 : return -EINVAL;
1358 : }
1359 :
1360 0 : if (arg->reserved) {
1361 0 : drm_dbg_atomic(dev, "commit failed: reserved field set\n");
1362 0 : return -EINVAL;
1363 : }
1364 :
1365 0 : if (arg->flags & DRM_MODE_PAGE_FLIP_ASYNC) {
1366 0 : drm_dbg_atomic(dev,
1367 : "commit failed: invalid flag DRM_MODE_PAGE_FLIP_ASYNC\n");
1368 0 : return -EINVAL;
1369 : }
1370 :
1371 : /* can't test and expect an event at the same time. */
1372 0 : if ((arg->flags & DRM_MODE_ATOMIC_TEST_ONLY) &&
1373 : (arg->flags & DRM_MODE_PAGE_FLIP_EVENT)) {
1374 0 : drm_dbg_atomic(dev,
1375 : "commit failed: page-flip event requested with test-only commit\n");
1376 0 : return -EINVAL;
1377 : }
1378 :
1379 0 : state = drm_atomic_state_alloc(dev);
1380 0 : if (!state)
1381 : return -ENOMEM;
1382 :
1383 0 : drm_modeset_acquire_init(&ctx, DRM_MODESET_ACQUIRE_INTERRUPTIBLE);
1384 0 : state->acquire_ctx = &ctx;
1385 0 : state->allow_modeset = !!(arg->flags & DRM_MODE_ATOMIC_ALLOW_MODESET);
1386 :
1387 : retry:
1388 0 : copied_objs = 0;
1389 0 : copied_props = 0;
1390 0 : fence_state = NULL;
1391 0 : num_fences = 0;
1392 :
1393 0 : for (i = 0; i < arg->count_objs; i++) {
1394 : uint32_t obj_id, count_props;
1395 : struct drm_mode_object *obj;
1396 :
1397 0 : if (get_user(obj_id, objs_ptr + copied_objs)) {
1398 : ret = -EFAULT;
1399 : goto out;
1400 : }
1401 :
1402 0 : obj = drm_mode_object_find(dev, file_priv, obj_id, DRM_MODE_OBJECT_ANY);
1403 0 : if (!obj) {
1404 0 : drm_dbg_atomic(dev, "cannot find object ID %d", obj_id);
1405 0 : ret = -ENOENT;
1406 0 : goto out;
1407 : }
1408 :
1409 0 : if (!obj->properties) {
1410 0 : drm_dbg_atomic(dev, "[OBJECT:%d] has no properties", obj_id);
1411 0 : drm_mode_object_put(obj);
1412 0 : ret = -ENOENT;
1413 0 : goto out;
1414 : }
1415 :
1416 0 : if (get_user(count_props, count_props_ptr + copied_objs)) {
1417 0 : drm_mode_object_put(obj);
1418 0 : ret = -EFAULT;
1419 0 : goto out;
1420 : }
1421 :
1422 0 : copied_objs++;
1423 :
1424 0 : for (j = 0; j < count_props; j++) {
1425 : uint32_t prop_id;
1426 : uint64_t prop_value;
1427 : struct drm_property *prop;
1428 :
1429 0 : if (get_user(prop_id, props_ptr + copied_props)) {
1430 0 : drm_mode_object_put(obj);
1431 0 : ret = -EFAULT;
1432 0 : goto out;
1433 : }
1434 :
1435 0 : prop = drm_mode_obj_find_prop_id(obj, prop_id);
1436 0 : if (!prop) {
1437 0 : drm_dbg_atomic(dev,
1438 : "[OBJECT:%d] cannot find property ID %d",
1439 : obj_id, prop_id);
1440 0 : drm_mode_object_put(obj);
1441 0 : ret = -ENOENT;
1442 0 : goto out;
1443 : }
1444 :
1445 0 : if (copy_from_user(&prop_value,
1446 0 : prop_values_ptr + copied_props,
1447 : sizeof(prop_value))) {
1448 0 : drm_mode_object_put(obj);
1449 0 : ret = -EFAULT;
1450 0 : goto out;
1451 : }
1452 :
1453 0 : ret = drm_atomic_set_property(state, file_priv,
1454 : obj, prop, prop_value);
1455 0 : if (ret) {
1456 0 : drm_mode_object_put(obj);
1457 0 : goto out;
1458 : }
1459 :
1460 0 : copied_props++;
1461 : }
1462 :
1463 0 : drm_mode_object_put(obj);
1464 : }
1465 :
1466 0 : ret = prepare_signaling(dev, state, arg, file_priv, &fence_state,
1467 : &num_fences);
1468 0 : if (ret)
1469 : goto out;
1470 :
1471 0 : if (arg->flags & DRM_MODE_ATOMIC_TEST_ONLY) {
1472 0 : ret = drm_atomic_check_only(state);
1473 0 : } else if (arg->flags & DRM_MODE_ATOMIC_NONBLOCK) {
1474 0 : ret = drm_atomic_nonblocking_commit(state);
1475 : } else {
1476 0 : ret = drm_atomic_commit(state);
1477 : }
1478 :
1479 : out:
1480 0 : complete_signaling(dev, state, fence_state, num_fences, !ret);
1481 :
1482 0 : if (ret == -EDEADLK) {
1483 0 : drm_atomic_state_clear(state);
1484 0 : ret = drm_modeset_backoff(&ctx);
1485 0 : if (!ret)
1486 : goto retry;
1487 : }
1488 :
1489 0 : drm_atomic_state_put(state);
1490 :
1491 0 : drm_modeset_drop_locks(&ctx);
1492 0 : drm_modeset_acquire_fini(&ctx);
1493 :
1494 0 : return ret;
1495 : }
|
