1 /*
2 * Copyright (C) 2014 Red Hat
3 * Copyright (C) 2014 Intel Corp.
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 * and/or sell copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following conditions:
11 *
12 * The above copyright notice and this permission notice shall be included in
13 * all copies or substantial portions of the Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
19 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
20 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
21 * OTHER DEALINGS IN THE SOFTWARE.
22 *
23 * Authors:
24 * Rob Clark <robdclark@gmail.com>
25 * Daniel Vetter <daniel.vetter@ffwll.ch>
26 */
27
28
29 #include <drm/drmP.h>
30 #include <drm/drm_atomic.h>
31 #include <drm/drm_plane_helper.h>
32
33 /**
34 * drm_atomic_state_default_release -
35 * release memory initialized by drm_atomic_state_init
36 * @state: atomic state
37 *
38 * Free all the memory allocated by drm_atomic_state_init.
39 * This is useful for drivers that subclass the atomic state.
40 */
drm_atomic_state_default_release(struct drm_atomic_state * state)41 void drm_atomic_state_default_release(struct drm_atomic_state *state)
42 {
43 kfree(state->connectors);
44 kfree(state->connector_states);
45 kfree(state->crtcs);
46 kfree(state->crtc_states);
47 kfree(state->planes);
48 kfree(state->plane_states);
49 }
50 EXPORT_SYMBOL(drm_atomic_state_default_release);
51
52 /**
53 * drm_atomic_state_init - init new atomic state
54 * @dev: DRM device
55 * @state: atomic state
56 *
57 * Default implementation for filling in a new atomic state.
58 * This is useful for drivers that subclass the atomic state.
59 */
60 int
drm_atomic_state_init(struct drm_device * dev,struct drm_atomic_state * state)61 drm_atomic_state_init(struct drm_device *dev, struct drm_atomic_state *state)
62 {
63 /* TODO legacy paths should maybe do a better job about
64 * setting this appropriately?
65 */
66 state->allow_modeset = true;
67
68 state->num_connector = ACCESS_ONCE(dev->mode_config.num_connector);
69
70 state->crtcs = kcalloc(dev->mode_config.num_crtc,
71 sizeof(*state->crtcs), GFP_KERNEL);
72 if (!state->crtcs)
73 goto fail;
74 state->crtc_states = kcalloc(dev->mode_config.num_crtc,
75 sizeof(*state->crtc_states), GFP_KERNEL);
76 if (!state->crtc_states)
77 goto fail;
78 state->planes = kcalloc(dev->mode_config.num_total_plane,
79 sizeof(*state->planes), GFP_KERNEL);
80 if (!state->planes)
81 goto fail;
82 state->plane_states = kcalloc(dev->mode_config.num_total_plane,
83 sizeof(*state->plane_states), GFP_KERNEL);
84 if (!state->plane_states)
85 goto fail;
86 state->connectors = kcalloc(state->num_connector,
87 sizeof(*state->connectors),
88 GFP_KERNEL);
89 if (!state->connectors)
90 goto fail;
91 state->connector_states = kcalloc(state->num_connector,
92 sizeof(*state->connector_states),
93 GFP_KERNEL);
94 if (!state->connector_states)
95 goto fail;
96
97 state->dev = dev;
98
99 DRM_DEBUG_ATOMIC("Allocated atomic state %p\n", state);
100
101 return 0;
102 fail:
103 drm_atomic_state_default_release(state);
104 return -ENOMEM;
105 }
106 EXPORT_SYMBOL(drm_atomic_state_init);
107
108 /**
109 * drm_atomic_state_alloc - allocate atomic state
110 * @dev: DRM device
111 *
112 * This allocates an empty atomic state to track updates.
113 */
114 struct drm_atomic_state *
drm_atomic_state_alloc(struct drm_device * dev)115 drm_atomic_state_alloc(struct drm_device *dev)
116 {
117 struct drm_mode_config *config = &dev->mode_config;
118 struct drm_atomic_state *state;
119
120 if (!config->funcs->atomic_state_alloc) {
121 state = kzalloc(sizeof(*state), GFP_KERNEL);
122 if (!state)
123 return NULL;
124 if (drm_atomic_state_init(dev, state) < 0) {
125 kfree(state);
126 return NULL;
127 }
128 return state;
129 }
130
131 return config->funcs->atomic_state_alloc(dev);
132 }
133 EXPORT_SYMBOL(drm_atomic_state_alloc);
134
135 /**
136 * drm_atomic_state_default_clear - clear base atomic state
137 * @state: atomic state
138 *
139 * Default implementation for clearing atomic state.
140 * This is useful for drivers that subclass the atomic state.
141 */
drm_atomic_state_default_clear(struct drm_atomic_state * state)142 void drm_atomic_state_default_clear(struct drm_atomic_state *state)
143 {
144 struct drm_device *dev = state->dev;
145 struct drm_mode_config *config = &dev->mode_config;
146 int i;
147
148 DRM_DEBUG_ATOMIC("Clearing atomic state %p\n", state);
149
150 for (i = 0; i < state->num_connector; i++) {
151 struct drm_connector *connector = state->connectors[i];
152
153 if (!connector || !connector->funcs)
154 continue;
155
156 /*
157 * FIXME: Async commits can race with connector unplugging and
158 * there's currently nothing that prevents cleanup up state for
159 * deleted connectors. As long as the callback doesn't look at
160 * the connector we'll be fine though, so make sure that's the
161 * case by setting all connector pointers to NULL.
162 */
163 state->connector_states[i]->connector = NULL;
164 connector->funcs->atomic_destroy_state(NULL,
165 state->connector_states[i]);
166 state->connectors[i] = NULL;
167 state->connector_states[i] = NULL;
168 }
169
170 for (i = 0; i < config->num_crtc; i++) {
171 struct drm_crtc *crtc = state->crtcs[i];
172
173 if (!crtc)
174 continue;
175
176 crtc->funcs->atomic_destroy_state(crtc,
177 state->crtc_states[i]);
178 state->crtcs[i] = NULL;
179 state->crtc_states[i] = NULL;
180 }
181
182 for (i = 0; i < config->num_total_plane; i++) {
183 struct drm_plane *plane = state->planes[i];
184
185 if (!plane)
186 continue;
187
188 plane->funcs->atomic_destroy_state(plane,
189 state->plane_states[i]);
190 state->planes[i] = NULL;
191 state->plane_states[i] = NULL;
192 }
193 }
194 EXPORT_SYMBOL(drm_atomic_state_default_clear);
195
196 /**
197 * drm_atomic_state_clear - clear state object
198 * @state: atomic state
199 *
200 * When the w/w mutex algorithm detects a deadlock we need to back off and drop
201 * all locks. So someone else could sneak in and change the current modeset
202 * configuration. Which means that all the state assembled in @state is no
203 * longer an atomic update to the current state, but to some arbitrary earlier
204 * state. Which could break assumptions the driver's ->atomic_check likely
205 * relies on.
206 *
207 * Hence we must clear all cached state and completely start over, using this
208 * function.
209 */
drm_atomic_state_clear(struct drm_atomic_state * state)210 void drm_atomic_state_clear(struct drm_atomic_state *state)
211 {
212 struct drm_device *dev = state->dev;
213 struct drm_mode_config *config = &dev->mode_config;
214
215 if (config->funcs->atomic_state_clear)
216 config->funcs->atomic_state_clear(state);
217 else
218 drm_atomic_state_default_clear(state);
219 }
220 EXPORT_SYMBOL(drm_atomic_state_clear);
221
222 /**
223 * drm_atomic_state_free - free all memory for an atomic state
224 * @state: atomic state to deallocate
225 *
226 * This frees all memory associated with an atomic state, including all the
227 * per-object state for planes, crtcs and connectors.
228 */
drm_atomic_state_free(struct drm_atomic_state * state)229 void drm_atomic_state_free(struct drm_atomic_state *state)
230 {
231 struct drm_device *dev;
232 struct drm_mode_config *config;
233
234 if (!state)
235 return;
236
237 dev = state->dev;
238 config = &dev->mode_config;
239
240 drm_atomic_state_clear(state);
241
242 DRM_DEBUG_ATOMIC("Freeing atomic state %p\n", state);
243
244 if (config->funcs->atomic_state_free) {
245 config->funcs->atomic_state_free(state);
246 } else {
247 drm_atomic_state_default_release(state);
248 kfree(state);
249 }
250 }
251 EXPORT_SYMBOL(drm_atomic_state_free);
252
253 /**
254 * drm_atomic_get_crtc_state - get crtc state
255 * @state: global atomic state object
256 * @crtc: crtc to get state object for
257 *
258 * This function returns the crtc state for the given crtc, allocating it if
259 * needed. It will also grab the relevant crtc lock to make sure that the state
260 * is consistent.
261 *
262 * Returns:
263 *
264 * Either the allocated state or the error code encoded into the pointer. When
265 * the error is EDEADLK then the w/w mutex code has detected a deadlock and the
266 * entire atomic sequence must be restarted. All other errors are fatal.
267 */
268 struct drm_crtc_state *
drm_atomic_get_crtc_state(struct drm_atomic_state * state,struct drm_crtc * crtc)269 drm_atomic_get_crtc_state(struct drm_atomic_state *state,
270 struct drm_crtc *crtc)
271 {
272 int ret, index = drm_crtc_index(crtc);
273 struct drm_crtc_state *crtc_state;
274
275 crtc_state = drm_atomic_get_existing_crtc_state(state, crtc);
276 if (crtc_state)
277 return crtc_state;
278
279 ret = drm_modeset_lock(&crtc->mutex, state->acquire_ctx);
280 if (ret)
281 return ERR_PTR(ret);
282
283 crtc_state = crtc->funcs->atomic_duplicate_state(crtc);
284 if (!crtc_state)
285 return ERR_PTR(-ENOMEM);
286
287 state->crtc_states[index] = crtc_state;
288 state->crtcs[index] = crtc;
289 crtc_state->state = state;
290
291 DRM_DEBUG_ATOMIC("Added [CRTC:%d] %p state to %p\n",
292 crtc->base.id, crtc_state, state);
293
294 return crtc_state;
295 }
296 EXPORT_SYMBOL(drm_atomic_get_crtc_state);
297
298 /**
299 * drm_atomic_set_mode_for_crtc - set mode for CRTC
300 * @state: the CRTC whose incoming state to update
301 * @mode: kernel-internal mode to use for the CRTC, or NULL to disable
302 *
303 * Set a mode (originating from the kernel) on the desired CRTC state. Does
304 * not change any other state properties, including enable, active, or
305 * mode_changed.
306 *
307 * RETURNS:
308 * Zero on success, error code on failure. Cannot return -EDEADLK.
309 */
drm_atomic_set_mode_for_crtc(struct drm_crtc_state * state,struct drm_display_mode * mode)310 int drm_atomic_set_mode_for_crtc(struct drm_crtc_state *state,
311 struct drm_display_mode *mode)
312 {
313 struct drm_mode_modeinfo umode;
314
315 /* Early return for no change. */
316 if (mode && memcmp(&state->mode, mode, sizeof(*mode)) == 0)
317 return 0;
318
319 if (state->mode_blob)
320 drm_property_unreference_blob(state->mode_blob);
321 state->mode_blob = NULL;
322
323 if (mode) {
324 drm_mode_convert_to_umode(&umode, mode);
325 state->mode_blob =
326 drm_property_create_blob(state->crtc->dev,
327 sizeof(umode),
328 &umode);
329 if (IS_ERR(state->mode_blob))
330 return PTR_ERR(state->mode_blob);
331
332 drm_mode_copy(&state->mode, mode);
333 state->enable = true;
334 DRM_DEBUG_ATOMIC("Set [MODE:%s] for CRTC state %p\n",
335 mode->name, state);
336 } else {
337 memset(&state->mode, 0, sizeof(state->mode));
338 state->enable = false;
339 DRM_DEBUG_ATOMIC("Set [NOMODE] for CRTC state %p\n",
340 state);
341 }
342
343 return 0;
344 }
345 EXPORT_SYMBOL(drm_atomic_set_mode_for_crtc);
346
347 /**
348 * drm_atomic_set_mode_prop_for_crtc - set mode for CRTC
349 * @state: the CRTC whose incoming state to update
350 * @blob: pointer to blob property to use for mode
351 *
352 * Set a mode (originating from a blob property) on the desired CRTC state.
353 * This function will take a reference on the blob property for the CRTC state,
354 * and release the reference held on the state's existing mode property, if any
355 * was set.
356 *
357 * RETURNS:
358 * Zero on success, error code on failure. Cannot return -EDEADLK.
359 */
drm_atomic_set_mode_prop_for_crtc(struct drm_crtc_state * state,struct drm_property_blob * blob)360 int drm_atomic_set_mode_prop_for_crtc(struct drm_crtc_state *state,
361 struct drm_property_blob *blob)
362 {
363 if (blob == state->mode_blob)
364 return 0;
365
366 if (state->mode_blob)
367 drm_property_unreference_blob(state->mode_blob);
368 state->mode_blob = NULL;
369
370 memset(&state->mode, 0, sizeof(state->mode));
371
372 if (blob) {
373 if (blob->length != sizeof(struct drm_mode_modeinfo) ||
374 drm_mode_convert_umode(&state->mode,
375 (const struct drm_mode_modeinfo *)
376 blob->data))
377 return -EINVAL;
378
379 state->mode_blob = drm_property_reference_blob(blob);
380 state->enable = true;
381 DRM_DEBUG_ATOMIC("Set [MODE:%s] for CRTC state %p\n",
382 state->mode.name, state);
383 } else {
384 state->enable = false;
385 DRM_DEBUG_ATOMIC("Set [NOMODE] for CRTC state %p\n",
386 state);
387 }
388
389 return 0;
390 }
391 EXPORT_SYMBOL(drm_atomic_set_mode_prop_for_crtc);
392
393 /**
394 * drm_atomic_crtc_set_property - set property on CRTC
395 * @crtc: the drm CRTC to set a property on
396 * @state: the state object to update with the new property value
397 * @property: the property to set
398 * @val: the new property value
399 *
400 * Use this instead of calling crtc->atomic_set_property directly.
401 * This function handles generic/core properties and calls out to
402 * driver's ->atomic_set_property() for driver properties. To ensure
403 * consistent behavior you must call this function rather than the
404 * driver hook directly.
405 *
406 * RETURNS:
407 * Zero on success, error code on failure
408 */
drm_atomic_crtc_set_property(struct drm_crtc * crtc,struct drm_crtc_state * state,struct drm_property * property,uint64_t val)409 int drm_atomic_crtc_set_property(struct drm_crtc *crtc,
410 struct drm_crtc_state *state, struct drm_property *property,
411 uint64_t val)
412 {
413 struct drm_device *dev = crtc->dev;
414 struct drm_mode_config *config = &dev->mode_config;
415 int ret;
416
417 if (property == config->prop_active)
418 state->active = val;
419 else if (property == config->prop_mode_id) {
420 struct drm_property_blob *mode =
421 drm_property_lookup_blob(dev, val);
422 ret = drm_atomic_set_mode_prop_for_crtc(state, mode);
423 if (mode)
424 drm_property_unreference_blob(mode);
425 return ret;
426 }
427 else if (crtc->funcs->atomic_set_property)
428 return crtc->funcs->atomic_set_property(crtc, state, property, val);
429 else
430 return -EINVAL;
431
432 return 0;
433 }
434 EXPORT_SYMBOL(drm_atomic_crtc_set_property);
435
436 /*
437 * This function handles generic/core properties and calls out to
438 * driver's ->atomic_get_property() for driver properties. To ensure
439 * consistent behavior you must call this function rather than the
440 * driver hook directly.
441 */
442 static int
drm_atomic_crtc_get_property(struct drm_crtc * crtc,const struct drm_crtc_state * state,struct drm_property * property,uint64_t * val)443 drm_atomic_crtc_get_property(struct drm_crtc *crtc,
444 const struct drm_crtc_state *state,
445 struct drm_property *property, uint64_t *val)
446 {
447 struct drm_device *dev = crtc->dev;
448 struct drm_mode_config *config = &dev->mode_config;
449
450 if (property == config->prop_active)
451 *val = state->active;
452 else if (property == config->prop_mode_id)
453 *val = (state->mode_blob) ? state->mode_blob->base.id : 0;
454 else if (crtc->funcs->atomic_get_property)
455 return crtc->funcs->atomic_get_property(crtc, state, property, val);
456 else
457 return -EINVAL;
458
459 return 0;
460 }
461
462 /**
463 * drm_atomic_crtc_check - check crtc state
464 * @crtc: crtc to check
465 * @state: crtc state to check
466 *
467 * Provides core sanity checks for crtc state.
468 *
469 * RETURNS:
470 * Zero on success, error code on failure
471 */
drm_atomic_crtc_check(struct drm_crtc * crtc,struct drm_crtc_state * state)472 static int drm_atomic_crtc_check(struct drm_crtc *crtc,
473 struct drm_crtc_state *state)
474 {
475 /* NOTE: we explicitly don't enforce constraints such as primary
476 * layer covering entire screen, since that is something we want
477 * to allow (on hw that supports it). For hw that does not, it
478 * should be checked in driver's crtc->atomic_check() vfunc.
479 *
480 * TODO: Add generic modeset state checks once we support those.
481 */
482
483 if (state->active && !state->enable) {
484 DRM_DEBUG_ATOMIC("[CRTC:%d] active without enabled\n",
485 crtc->base.id);
486 return -EINVAL;
487 }
488
489 /* The state->enable vs. state->mode_blob checks can be WARN_ON,
490 * as this is a kernel-internal detail that userspace should never
491 * be able to trigger. */
492 if (drm_core_check_feature(crtc->dev, DRIVER_ATOMIC) &&
493 WARN_ON(state->enable && !state->mode_blob)) {
494 DRM_DEBUG_ATOMIC("[CRTC:%d] enabled without mode blob\n",
495 crtc->base.id);
496 return -EINVAL;
497 }
498
499 if (drm_core_check_feature(crtc->dev, DRIVER_ATOMIC) &&
500 WARN_ON(!state->enable && state->mode_blob)) {
501 DRM_DEBUG_ATOMIC("[CRTC:%d] disabled with mode blob\n",
502 crtc->base.id);
503 return -EINVAL;
504 }
505
506 return 0;
507 }
508
509 /**
510 * drm_atomic_get_plane_state - get plane state
511 * @state: global atomic state object
512 * @plane: plane to get state object for
513 *
514 * This function returns the plane state for the given plane, allocating it if
515 * needed. It will also grab the relevant plane lock to make sure that the state
516 * is consistent.
517 *
518 * Returns:
519 *
520 * Either the allocated state or the error code encoded into the pointer. When
521 * the error is EDEADLK then the w/w mutex code has detected a deadlock and the
522 * entire atomic sequence must be restarted. All other errors are fatal.
523 */
524 struct drm_plane_state *
drm_atomic_get_plane_state(struct drm_atomic_state * state,struct drm_plane * plane)525 drm_atomic_get_plane_state(struct drm_atomic_state *state,
526 struct drm_plane *plane)
527 {
528 int ret, index = drm_plane_index(plane);
529 struct drm_plane_state *plane_state;
530
531 plane_state = drm_atomic_get_existing_plane_state(state, plane);
532 if (plane_state)
533 return plane_state;
534
535 ret = drm_modeset_lock(&plane->mutex, state->acquire_ctx);
536 if (ret)
537 return ERR_PTR(ret);
538
539 plane_state = plane->funcs->atomic_duplicate_state(plane);
540 if (!plane_state)
541 return ERR_PTR(-ENOMEM);
542
543 state->plane_states[index] = plane_state;
544 state->planes[index] = plane;
545 plane_state->state = state;
546
547 DRM_DEBUG_ATOMIC("Added [PLANE:%d] %p state to %p\n",
548 plane->base.id, plane_state, state);
549
550 if (plane_state->crtc) {
551 struct drm_crtc_state *crtc_state;
552
553 crtc_state = drm_atomic_get_crtc_state(state,
554 plane_state->crtc);
555 if (IS_ERR(crtc_state))
556 return ERR_CAST(crtc_state);
557 }
558
559 return plane_state;
560 }
561 EXPORT_SYMBOL(drm_atomic_get_plane_state);
562
563 /**
564 * drm_atomic_plane_set_property - set property on plane
565 * @plane: the drm plane to set a property on
566 * @state: the state object to update with the new property value
567 * @property: the property to set
568 * @val: the new property value
569 *
570 * Use this instead of calling plane->atomic_set_property directly.
571 * This function handles generic/core properties and calls out to
572 * driver's ->atomic_set_property() for driver properties. To ensure
573 * consistent behavior you must call this function rather than the
574 * driver hook directly.
575 *
576 * RETURNS:
577 * Zero on success, error code on failure
578 */
drm_atomic_plane_set_property(struct drm_plane * plane,struct drm_plane_state * state,struct drm_property * property,uint64_t val)579 int drm_atomic_plane_set_property(struct drm_plane *plane,
580 struct drm_plane_state *state, struct drm_property *property,
581 uint64_t val)
582 {
583 struct drm_device *dev = plane->dev;
584 struct drm_mode_config *config = &dev->mode_config;
585
586 if (property == config->prop_fb_id) {
587 struct drm_framebuffer *fb = drm_framebuffer_lookup(dev, val);
588 drm_atomic_set_fb_for_plane(state, fb);
589 if (fb)
590 drm_framebuffer_unreference(fb);
591 } else if (property == config->prop_crtc_id) {
592 struct drm_crtc *crtc = drm_crtc_find(dev, val);
593 return drm_atomic_set_crtc_for_plane(state, crtc);
594 } else if (property == config->prop_crtc_x) {
595 state->crtc_x = U642I64(val);
596 } else if (property == config->prop_crtc_y) {
597 state->crtc_y = U642I64(val);
598 } else if (property == config->prop_crtc_w) {
599 state->crtc_w = val;
600 } else if (property == config->prop_crtc_h) {
601 state->crtc_h = val;
602 } else if (property == config->prop_src_x) {
603 state->src_x = val;
604 } else if (property == config->prop_src_y) {
605 state->src_y = val;
606 } else if (property == config->prop_src_w) {
607 state->src_w = val;
608 } else if (property == config->prop_src_h) {
609 state->src_h = val;
610 } else if (property == config->rotation_property) {
611 state->rotation = val;
612 } else if (plane->funcs->atomic_set_property) {
613 return plane->funcs->atomic_set_property(plane, state,
614 property, val);
615 } else {
616 return -EINVAL;
617 }
618
619 return 0;
620 }
621 EXPORT_SYMBOL(drm_atomic_plane_set_property);
622
623 /*
624 * This function handles generic/core properties and calls out to
625 * driver's ->atomic_get_property() for driver properties. To ensure
626 * consistent behavior you must call this function rather than the
627 * driver hook directly.
628 */
629 static int
drm_atomic_plane_get_property(struct drm_plane * plane,const struct drm_plane_state * state,struct drm_property * property,uint64_t * val)630 drm_atomic_plane_get_property(struct drm_plane *plane,
631 const struct drm_plane_state *state,
632 struct drm_property *property, uint64_t *val)
633 {
634 struct drm_device *dev = plane->dev;
635 struct drm_mode_config *config = &dev->mode_config;
636
637 if (property == config->prop_fb_id) {
638 *val = (state->fb) ? state->fb->base.id : 0;
639 } else if (property == config->prop_crtc_id) {
640 *val = (state->crtc) ? state->crtc->base.id : 0;
641 } else if (property == config->prop_crtc_x) {
642 *val = I642U64(state->crtc_x);
643 } else if (property == config->prop_crtc_y) {
644 *val = I642U64(state->crtc_y);
645 } else if (property == config->prop_crtc_w) {
646 *val = state->crtc_w;
647 } else if (property == config->prop_crtc_h) {
648 *val = state->crtc_h;
649 } else if (property == config->prop_src_x) {
650 *val = state->src_x;
651 } else if (property == config->prop_src_y) {
652 *val = state->src_y;
653 } else if (property == config->prop_src_w) {
654 *val = state->src_w;
655 } else if (property == config->prop_src_h) {
656 *val = state->src_h;
657 } else if (property == config->rotation_property) {
658 *val = state->rotation;
659 } else if (plane->funcs->atomic_get_property) {
660 return plane->funcs->atomic_get_property(plane, state, property, val);
661 } else {
662 return -EINVAL;
663 }
664
665 return 0;
666 }
667
668 static bool
plane_switching_crtc(struct drm_atomic_state * state,struct drm_plane * plane,struct drm_plane_state * plane_state)669 plane_switching_crtc(struct drm_atomic_state *state,
670 struct drm_plane *plane,
671 struct drm_plane_state *plane_state)
672 {
673 if (!plane->state->crtc || !plane_state->crtc)
674 return false;
675
676 if (plane->state->crtc == plane_state->crtc)
677 return false;
678
679 /* This could be refined, but currently there's no helper or driver code
680 * to implement direct switching of active planes nor userspace to take
681 * advantage of more direct plane switching without the intermediate
682 * full OFF state.
683 */
684 return true;
685 }
686
687 /**
688 * drm_atomic_plane_check - check plane state
689 * @plane: plane to check
690 * @state: plane state to check
691 *
692 * Provides core sanity checks for plane state.
693 *
694 * RETURNS:
695 * Zero on success, error code on failure
696 */
drm_atomic_plane_check(struct drm_plane * plane,struct drm_plane_state * state)697 static int drm_atomic_plane_check(struct drm_plane *plane,
698 struct drm_plane_state *state)
699 {
700 unsigned int fb_width, fb_height;
701 int ret;
702
703 /* either *both* CRTC and FB must be set, or neither */
704 if (WARN_ON(state->crtc && !state->fb)) {
705 DRM_DEBUG_ATOMIC("CRTC set but no FB\n");
706 return -EINVAL;
707 } else if (WARN_ON(state->fb && !state->crtc)) {
708 DRM_DEBUG_ATOMIC("FB set but no CRTC\n");
709 return -EINVAL;
710 }
711
712 /* if disabled, we don't care about the rest of the state: */
713 if (!state->crtc)
714 return 0;
715
716 /* Check whether this plane is usable on this CRTC */
717 if (!(plane->possible_crtcs & drm_crtc_mask(state->crtc))) {
718 DRM_DEBUG_ATOMIC("Invalid crtc for plane\n");
719 return -EINVAL;
720 }
721
722 /* Check whether this plane supports the fb pixel format. */
723 ret = drm_plane_check_pixel_format(plane, state->fb->pixel_format);
724 if (ret) {
725 DRM_DEBUG_ATOMIC("Invalid pixel format %s\n",
726 drm_get_format_name(state->fb->pixel_format));
727 return ret;
728 }
729
730 /* Give drivers some help against integer overflows */
731 if (state->crtc_w > INT_MAX ||
732 state->crtc_x > INT_MAX - (int32_t) state->crtc_w ||
733 state->crtc_h > INT_MAX ||
734 state->crtc_y > INT_MAX - (int32_t) state->crtc_h) {
735 DRM_DEBUG_ATOMIC("Invalid CRTC coordinates %ux%u+%d+%d\n",
736 state->crtc_w, state->crtc_h,
737 state->crtc_x, state->crtc_y);
738 return -ERANGE;
739 }
740
741 fb_width = state->fb->width << 16;
742 fb_height = state->fb->height << 16;
743
744 /* Make sure source coordinates are inside the fb. */
745 if (state->src_w > fb_width ||
746 state->src_x > fb_width - state->src_w ||
747 state->src_h > fb_height ||
748 state->src_y > fb_height - state->src_h) {
749 DRM_DEBUG_ATOMIC("Invalid source coordinates "
750 "%u.%06ux%u.%06u+%u.%06u+%u.%06u\n",
751 state->src_w >> 16, ((state->src_w & 0xffff) * 15625) >> 10,
752 state->src_h >> 16, ((state->src_h & 0xffff) * 15625) >> 10,
753 state->src_x >> 16, ((state->src_x & 0xffff) * 15625) >> 10,
754 state->src_y >> 16, ((state->src_y & 0xffff) * 15625) >> 10);
755 return -ENOSPC;
756 }
757
758 if (plane_switching_crtc(state->state, plane, state)) {
759 DRM_DEBUG_ATOMIC("[PLANE:%d] switching CRTC directly\n",
760 plane->base.id);
761 return -EINVAL;
762 }
763
764 return 0;
765 }
766
767 /**
768 * drm_atomic_get_connector_state - get connector state
769 * @state: global atomic state object
770 * @connector: connector to get state object for
771 *
772 * This function returns the connector state for the given connector,
773 * allocating it if needed. It will also grab the relevant connector lock to
774 * make sure that the state is consistent.
775 *
776 * Returns:
777 *
778 * Either the allocated state or the error code encoded into the pointer. When
779 * the error is EDEADLK then the w/w mutex code has detected a deadlock and the
780 * entire atomic sequence must be restarted. All other errors are fatal.
781 */
782 struct drm_connector_state *
drm_atomic_get_connector_state(struct drm_atomic_state * state,struct drm_connector * connector)783 drm_atomic_get_connector_state(struct drm_atomic_state *state,
784 struct drm_connector *connector)
785 {
786 int ret, index;
787 struct drm_mode_config *config = &connector->dev->mode_config;
788 struct drm_connector_state *connector_state;
789
790 ret = drm_modeset_lock(&config->connection_mutex, state->acquire_ctx);
791 if (ret)
792 return ERR_PTR(ret);
793
794 index = drm_connector_index(connector);
795
796 /*
797 * Construction of atomic state updates can race with a connector
798 * hot-add which might overflow. In this case flip the table and just
799 * restart the entire ioctl - no one is fast enough to livelock a cpu
800 * with physical hotplug events anyway.
801 *
802 * Note that we only grab the indexes once we have the right lock to
803 * prevent hotplug/unplugging of connectors. So removal is no problem,
804 * at most the array is a bit too large.
805 */
806 if (index >= state->num_connector) {
807 DRM_DEBUG_ATOMIC("Hot-added connector would overflow state array, restarting\n");
808 return ERR_PTR(-EAGAIN);
809 }
810
811 if (state->connector_states[index])
812 return state->connector_states[index];
813
814 connector_state = connector->funcs->atomic_duplicate_state(connector);
815 if (!connector_state)
816 return ERR_PTR(-ENOMEM);
817
818 state->connector_states[index] = connector_state;
819 state->connectors[index] = connector;
820 connector_state->state = state;
821
822 DRM_DEBUG_ATOMIC("Added [CONNECTOR:%d] %p state to %p\n",
823 connector->base.id, connector_state, state);
824
825 if (connector_state->crtc) {
826 struct drm_crtc_state *crtc_state;
827
828 crtc_state = drm_atomic_get_crtc_state(state,
829 connector_state->crtc);
830 if (IS_ERR(crtc_state))
831 return ERR_CAST(crtc_state);
832 }
833
834 return connector_state;
835 }
836 EXPORT_SYMBOL(drm_atomic_get_connector_state);
837
838 /**
839 * drm_atomic_connector_set_property - set property on connector.
840 * @connector: the drm connector to set a property on
841 * @state: the state object to update with the new property value
842 * @property: the property to set
843 * @val: the new property value
844 *
845 * Use this instead of calling connector->atomic_set_property directly.
846 * This function handles generic/core properties and calls out to
847 * driver's ->atomic_set_property() for driver properties. To ensure
848 * consistent behavior you must call this function rather than the
849 * driver hook directly.
850 *
851 * RETURNS:
852 * Zero on success, error code on failure
853 */
drm_atomic_connector_set_property(struct drm_connector * connector,struct drm_connector_state * state,struct drm_property * property,uint64_t val)854 int drm_atomic_connector_set_property(struct drm_connector *connector,
855 struct drm_connector_state *state, struct drm_property *property,
856 uint64_t val)
857 {
858 struct drm_device *dev = connector->dev;
859 struct drm_mode_config *config = &dev->mode_config;
860
861 if (property == config->prop_crtc_id) {
862 struct drm_crtc *crtc = drm_crtc_find(dev, val);
863 return drm_atomic_set_crtc_for_connector(state, crtc);
864 } else if (property == config->dpms_property) {
865 /* setting DPMS property requires special handling, which
866 * is done in legacy setprop path for us. Disallow (for
867 * now?) atomic writes to DPMS property:
868 */
869 return -EINVAL;
870 } else if (connector->funcs->atomic_set_property) {
871 return connector->funcs->atomic_set_property(connector,
872 state, property, val);
873 } else {
874 return -EINVAL;
875 }
876 }
877 EXPORT_SYMBOL(drm_atomic_connector_set_property);
878
879 /*
880 * This function handles generic/core properties and calls out to
881 * driver's ->atomic_get_property() for driver properties. To ensure
882 * consistent behavior you must call this function rather than the
883 * driver hook directly.
884 */
885 static int
drm_atomic_connector_get_property(struct drm_connector * connector,const struct drm_connector_state * state,struct drm_property * property,uint64_t * val)886 drm_atomic_connector_get_property(struct drm_connector *connector,
887 const struct drm_connector_state *state,
888 struct drm_property *property, uint64_t *val)
889 {
890 struct drm_device *dev = connector->dev;
891 struct drm_mode_config *config = &dev->mode_config;
892
893 if (property == config->prop_crtc_id) {
894 *val = (state->crtc) ? state->crtc->base.id : 0;
895 } else if (property == config->dpms_property) {
896 *val = connector->dpms;
897 } else if (connector->funcs->atomic_get_property) {
898 return connector->funcs->atomic_get_property(connector,
899 state, property, val);
900 } else {
901 return -EINVAL;
902 }
903
904 return 0;
905 }
906
drm_atomic_get_property(struct drm_mode_object * obj,struct drm_property * property,uint64_t * val)907 int drm_atomic_get_property(struct drm_mode_object *obj,
908 struct drm_property *property, uint64_t *val)
909 {
910 struct drm_device *dev = property->dev;
911 int ret;
912
913 switch (obj->type) {
914 case DRM_MODE_OBJECT_CONNECTOR: {
915 struct drm_connector *connector = obj_to_connector(obj);
916 WARN_ON(!drm_modeset_is_locked(&dev->mode_config.connection_mutex));
917 ret = drm_atomic_connector_get_property(connector,
918 connector->state, property, val);
919 break;
920 }
921 case DRM_MODE_OBJECT_CRTC: {
922 struct drm_crtc *crtc = obj_to_crtc(obj);
923 WARN_ON(!drm_modeset_is_locked(&crtc->mutex));
924 ret = drm_atomic_crtc_get_property(crtc,
925 crtc->state, property, val);
926 break;
927 }
928 case DRM_MODE_OBJECT_PLANE: {
929 struct drm_plane *plane = obj_to_plane(obj);
930 WARN_ON(!drm_modeset_is_locked(&plane->mutex));
931 ret = drm_atomic_plane_get_property(plane,
932 plane->state, property, val);
933 break;
934 }
935 default:
936 ret = -EINVAL;
937 break;
938 }
939
940 return ret;
941 }
942
943 /**
944 * drm_atomic_set_crtc_for_plane - set crtc for plane
945 * @plane_state: the plane whose incoming state to update
946 * @crtc: crtc to use for the plane
947 *
948 * Changing the assigned crtc for a plane requires us to grab the lock and state
949 * for the new crtc, as needed. This function takes care of all these details
950 * besides updating the pointer in the state object itself.
951 *
952 * Returns:
953 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
954 * then the w/w mutex code has detected a deadlock and the entire atomic
955 * sequence must be restarted. All other errors are fatal.
956 */
957 int
drm_atomic_set_crtc_for_plane(struct drm_plane_state * plane_state,struct drm_crtc * crtc)958 drm_atomic_set_crtc_for_plane(struct drm_plane_state *plane_state,
959 struct drm_crtc *crtc)
960 {
961 struct drm_plane *plane = plane_state->plane;
962 struct drm_crtc_state *crtc_state;
963 /* Nothing to do for same crtc*/
964 if (plane_state->crtc == crtc)
965 return 0;
966 if (plane_state->crtc) {
967 crtc_state = drm_atomic_get_crtc_state(plane_state->state,
968 plane_state->crtc);
969 if (WARN_ON(IS_ERR(crtc_state)))
970 return PTR_ERR(crtc_state);
971
972 crtc_state->plane_mask &= ~(1 << drm_plane_index(plane));
973 }
974
975 plane_state->crtc = crtc;
976
977 if (crtc) {
978 crtc_state = drm_atomic_get_crtc_state(plane_state->state,
979 crtc);
980 if (IS_ERR(crtc_state))
981 return PTR_ERR(crtc_state);
982 crtc_state->plane_mask |= (1 << drm_plane_index(plane));
983 }
984
985 if (crtc)
986 DRM_DEBUG_ATOMIC("Link plane state %p to [CRTC:%d]\n",
987 plane_state, crtc->base.id);
988 else
989 DRM_DEBUG_ATOMIC("Link plane state %p to [NOCRTC]\n",
990 plane_state);
991
992 return 0;
993 }
994 EXPORT_SYMBOL(drm_atomic_set_crtc_for_plane);
995
996 /**
997 * drm_atomic_set_fb_for_plane - set framebuffer for plane
998 * @plane_state: atomic state object for the plane
999 * @fb: fb to use for the plane
1000 *
1001 * Changing the assigned framebuffer for a plane requires us to grab a reference
1002 * to the new fb and drop the reference to the old fb, if there is one. This
1003 * function takes care of all these details besides updating the pointer in the
1004 * state object itself.
1005 */
1006 void
drm_atomic_set_fb_for_plane(struct drm_plane_state * plane_state,struct drm_framebuffer * fb)1007 drm_atomic_set_fb_for_plane(struct drm_plane_state *plane_state,
1008 struct drm_framebuffer *fb)
1009 {
1010 if (plane_state->fb)
1011 drm_framebuffer_unreference(plane_state->fb);
1012 if (fb)
1013 drm_framebuffer_reference(fb);
1014 plane_state->fb = fb;
1015
1016 if (fb)
1017 DRM_DEBUG_ATOMIC("Set [FB:%d] for plane state %p\n",
1018 fb->base.id, plane_state);
1019 else
1020 DRM_DEBUG_ATOMIC("Set [NOFB] for plane state %p\n",
1021 plane_state);
1022 }
1023 EXPORT_SYMBOL(drm_atomic_set_fb_for_plane);
1024
1025 /**
1026 * drm_atomic_set_crtc_for_connector - set crtc for connector
1027 * @conn_state: atomic state object for the connector
1028 * @crtc: crtc to use for the connector
1029 *
1030 * Changing the assigned crtc for a connector requires us to grab the lock and
1031 * state for the new crtc, as needed. This function takes care of all these
1032 * details besides updating the pointer in the state object itself.
1033 *
1034 * Returns:
1035 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
1036 * then the w/w mutex code has detected a deadlock and the entire atomic
1037 * sequence must be restarted. All other errors are fatal.
1038 */
1039 int
drm_atomic_set_crtc_for_connector(struct drm_connector_state * conn_state,struct drm_crtc * crtc)1040 drm_atomic_set_crtc_for_connector(struct drm_connector_state *conn_state,
1041 struct drm_crtc *crtc)
1042 {
1043 struct drm_crtc_state *crtc_state;
1044
1045 if (crtc) {
1046 crtc_state = drm_atomic_get_crtc_state(conn_state->state, crtc);
1047 if (IS_ERR(crtc_state))
1048 return PTR_ERR(crtc_state);
1049 }
1050
1051 conn_state->crtc = crtc;
1052
1053 if (crtc)
1054 DRM_DEBUG_ATOMIC("Link connector state %p to [CRTC:%d]\n",
1055 conn_state, crtc->base.id);
1056 else
1057 DRM_DEBUG_ATOMIC("Link connector state %p to [NOCRTC]\n",
1058 conn_state);
1059
1060 return 0;
1061 }
1062 EXPORT_SYMBOL(drm_atomic_set_crtc_for_connector);
1063
1064 /**
1065 * drm_atomic_add_affected_connectors - add connectors for crtc
1066 * @state: atomic state
1067 * @crtc: DRM crtc
1068 *
1069 * This function walks the current configuration and adds all connectors
1070 * currently using @crtc to the atomic configuration @state. Note that this
1071 * function must acquire the connection mutex. This can potentially cause
1072 * unneeded seralization if the update is just for the planes on one crtc. Hence
1073 * drivers and helpers should only call this when really needed (e.g. when a
1074 * full modeset needs to happen due to some change).
1075 *
1076 * Returns:
1077 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
1078 * then the w/w mutex code has detected a deadlock and the entire atomic
1079 * sequence must be restarted. All other errors are fatal.
1080 */
1081 int
drm_atomic_add_affected_connectors(struct drm_atomic_state * state,struct drm_crtc * crtc)1082 drm_atomic_add_affected_connectors(struct drm_atomic_state *state,
1083 struct drm_crtc *crtc)
1084 {
1085 struct drm_mode_config *config = &state->dev->mode_config;
1086 struct drm_connector *connector;
1087 struct drm_connector_state *conn_state;
1088 int ret;
1089
1090 ret = drm_modeset_lock(&config->connection_mutex, state->acquire_ctx);
1091 if (ret)
1092 return ret;
1093
1094 DRM_DEBUG_ATOMIC("Adding all current connectors for [CRTC:%d] to %p\n",
1095 crtc->base.id, state);
1096
1097 /*
1098 * Changed connectors are already in @state, so only need to look at the
1099 * current configuration.
1100 */
1101 drm_for_each_connector(connector, state->dev) {
1102 if (connector->state->crtc != crtc)
1103 continue;
1104
1105 conn_state = drm_atomic_get_connector_state(state, connector);
1106 if (IS_ERR(conn_state))
1107 return PTR_ERR(conn_state);
1108 }
1109
1110 return 0;
1111 }
1112 EXPORT_SYMBOL(drm_atomic_add_affected_connectors);
1113
1114 /**
1115 * drm_atomic_add_affected_planes - add planes for crtc
1116 * @state: atomic state
1117 * @crtc: DRM crtc
1118 *
1119 * This function walks the current configuration and adds all planes
1120 * currently used by @crtc to the atomic configuration @state. This is useful
1121 * when an atomic commit also needs to check all currently enabled plane on
1122 * @crtc, e.g. when changing the mode. It's also useful when re-enabling a CRTC
1123 * to avoid special code to force-enable all planes.
1124 *
1125 * Since acquiring a plane state will always also acquire the w/w mutex of the
1126 * current CRTC for that plane (if there is any) adding all the plane states for
1127 * a CRTC will not reduce parallism of atomic updates.
1128 *
1129 * Returns:
1130 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
1131 * then the w/w mutex code has detected a deadlock and the entire atomic
1132 * sequence must be restarted. All other errors are fatal.
1133 */
1134 int
drm_atomic_add_affected_planes(struct drm_atomic_state * state,struct drm_crtc * crtc)1135 drm_atomic_add_affected_planes(struct drm_atomic_state *state,
1136 struct drm_crtc *crtc)
1137 {
1138 struct drm_plane *plane;
1139
1140 WARN_ON(!drm_atomic_get_existing_crtc_state(state, crtc));
1141
1142 drm_for_each_plane_mask(plane, state->dev, crtc->state->plane_mask) {
1143 struct drm_plane_state *plane_state =
1144 drm_atomic_get_plane_state(state, plane);
1145
1146 if (IS_ERR(plane_state))
1147 return PTR_ERR(plane_state);
1148 }
1149 return 0;
1150 }
1151 EXPORT_SYMBOL(drm_atomic_add_affected_planes);
1152
1153 /**
1154 * drm_atomic_connectors_for_crtc - count number of connected outputs
1155 * @state: atomic state
1156 * @crtc: DRM crtc
1157 *
1158 * This function counts all connectors which will be connected to @crtc
1159 * according to @state. Useful to recompute the enable state for @crtc.
1160 */
1161 int
drm_atomic_connectors_for_crtc(struct drm_atomic_state * state,struct drm_crtc * crtc)1162 drm_atomic_connectors_for_crtc(struct drm_atomic_state *state,
1163 struct drm_crtc *crtc)
1164 {
1165 struct drm_connector *connector;
1166 struct drm_connector_state *conn_state;
1167
1168 int i, num_connected_connectors = 0;
1169
1170 for_each_connector_in_state(state, connector, conn_state, i) {
1171 if (conn_state->crtc == crtc)
1172 num_connected_connectors++;
1173 }
1174
1175 DRM_DEBUG_ATOMIC("State %p has %i connectors for [CRTC:%d]\n",
1176 state, num_connected_connectors, crtc->base.id);
1177
1178 return num_connected_connectors;
1179 }
1180 EXPORT_SYMBOL(drm_atomic_connectors_for_crtc);
1181
1182 /**
1183 * drm_atomic_legacy_backoff - locking backoff for legacy ioctls
1184 * @state: atomic state
1185 *
1186 * This function should be used by legacy entry points which don't understand
1187 * -EDEADLK semantics. For simplicity this one will grab all modeset locks after
1188 * the slowpath completed.
1189 */
drm_atomic_legacy_backoff(struct drm_atomic_state * state)1190 void drm_atomic_legacy_backoff(struct drm_atomic_state *state)
1191 {
1192 int ret;
1193
1194 retry:
1195 drm_modeset_backoff(state->acquire_ctx);
1196
1197 ret = drm_modeset_lock(&state->dev->mode_config.connection_mutex,
1198 state->acquire_ctx);
1199 if (ret)
1200 goto retry;
1201 ret = drm_modeset_lock_all_crtcs(state->dev,
1202 state->acquire_ctx);
1203 if (ret)
1204 goto retry;
1205 }
1206 EXPORT_SYMBOL(drm_atomic_legacy_backoff);
1207
1208 /**
1209 * drm_atomic_check_only - check whether a given config would work
1210 * @state: atomic configuration to check
1211 *
1212 * Note that this function can return -EDEADLK if the driver needed to acquire
1213 * more locks but encountered a deadlock. The caller must then do the usual w/w
1214 * backoff dance and restart. All other errors are fatal.
1215 *
1216 * Returns:
1217 * 0 on success, negative error code on failure.
1218 */
drm_atomic_check_only(struct drm_atomic_state * state)1219 int drm_atomic_check_only(struct drm_atomic_state *state)
1220 {
1221 struct drm_device *dev = state->dev;
1222 struct drm_mode_config *config = &dev->mode_config;
1223 struct drm_plane *plane;
1224 struct drm_plane_state *plane_state;
1225 struct drm_crtc *crtc;
1226 struct drm_crtc_state *crtc_state;
1227 int i, ret = 0;
1228
1229 DRM_DEBUG_ATOMIC("checking %p\n", state);
1230
1231 for_each_plane_in_state(state, plane, plane_state, i) {
1232 ret = drm_atomic_plane_check(plane, plane_state);
1233 if (ret) {
1234 DRM_DEBUG_ATOMIC("[PLANE:%d] atomic core check failed\n",
1235 plane->base.id);
1236 return ret;
1237 }
1238 }
1239
1240 for_each_crtc_in_state(state, crtc, crtc_state, i) {
1241 ret = drm_atomic_crtc_check(crtc, crtc_state);
1242 if (ret) {
1243 DRM_DEBUG_ATOMIC("[CRTC:%d] atomic core check failed\n",
1244 crtc->base.id);
1245 return ret;
1246 }
1247 }
1248
1249 if (config->funcs->atomic_check)
1250 ret = config->funcs->atomic_check(state->dev, state);
1251
1252 if (ret)
1253 return ret;
1254
1255 if (!state->allow_modeset) {
1256 for_each_crtc_in_state(state, crtc, crtc_state, i) {
1257 if (drm_atomic_crtc_needs_modeset(crtc_state)) {
1258 DRM_DEBUG_ATOMIC("[CRTC:%d] requires full modeset\n",
1259 crtc->base.id);
1260 return -EINVAL;
1261 }
1262 }
1263 }
1264
1265 return 0;
1266 }
1267 EXPORT_SYMBOL(drm_atomic_check_only);
1268
1269 /**
1270 * drm_atomic_commit - commit configuration atomically
1271 * @state: atomic configuration to check
1272 *
1273 * Note that this function can return -EDEADLK if the driver needed to acquire
1274 * more locks but encountered a deadlock. The caller must then do the usual w/w
1275 * backoff dance and restart. All other errors are fatal.
1276 *
1277 * Also note that on successful execution ownership of @state is transferred
1278 * from the caller of this function to the function itself. The caller must not
1279 * free or in any other way access @state. If the function fails then the caller
1280 * must clean up @state itself.
1281 *
1282 * Returns:
1283 * 0 on success, negative error code on failure.
1284 */
drm_atomic_commit(struct drm_atomic_state * state)1285 int drm_atomic_commit(struct drm_atomic_state *state)
1286 {
1287 struct drm_mode_config *config = &state->dev->mode_config;
1288 int ret;
1289
1290 ret = drm_atomic_check_only(state);
1291 if (ret)
1292 return ret;
1293
1294 DRM_DEBUG_ATOMIC("commiting %p\n", state);
1295
1296 return config->funcs->atomic_commit(state->dev, state, false);
1297 }
1298 EXPORT_SYMBOL(drm_atomic_commit);
1299
1300 /**
1301 * drm_atomic_async_commit - atomic&async configuration commit
1302 * @state: atomic configuration to check
1303 *
1304 * Note that this function can return -EDEADLK if the driver needed to acquire
1305 * more locks but encountered a deadlock. The caller must then do the usual w/w
1306 * backoff dance and restart. All other errors are fatal.
1307 *
1308 * Also note that on successful execution ownership of @state is transferred
1309 * from the caller of this function to the function itself. The caller must not
1310 * free or in any other way access @state. If the function fails then the caller
1311 * must clean up @state itself.
1312 *
1313 * Returns:
1314 * 0 on success, negative error code on failure.
1315 */
drm_atomic_async_commit(struct drm_atomic_state * state)1316 int drm_atomic_async_commit(struct drm_atomic_state *state)
1317 {
1318 struct drm_mode_config *config = &state->dev->mode_config;
1319 int ret;
1320
1321 ret = drm_atomic_check_only(state);
1322 if (ret)
1323 return ret;
1324
1325 DRM_DEBUG_ATOMIC("commiting %p asynchronously\n", state);
1326
1327 return config->funcs->atomic_commit(state->dev, state, true);
1328 }
1329 EXPORT_SYMBOL(drm_atomic_async_commit);
1330
1331 /*
1332 * The big monstor ioctl
1333 */
1334
create_vblank_event(struct drm_device * dev,struct drm_file * file_priv,uint64_t user_data)1335 static struct drm_pending_vblank_event *create_vblank_event(
1336 struct drm_device *dev, struct drm_file *file_priv, uint64_t user_data)
1337 {
1338 struct drm_pending_vblank_event *e = NULL;
1339 unsigned long flags;
1340
1341 spin_lock_irqsave(&dev->event_lock, flags);
1342 if (file_priv->event_space < sizeof e->event) {
1343 spin_unlock_irqrestore(&dev->event_lock, flags);
1344 goto out;
1345 }
1346 file_priv->event_space -= sizeof e->event;
1347 spin_unlock_irqrestore(&dev->event_lock, flags);
1348
1349 e = kzalloc(sizeof *e, GFP_KERNEL);
1350 if (e == NULL) {
1351 spin_lock_irqsave(&dev->event_lock, flags);
1352 file_priv->event_space += sizeof e->event;
1353 spin_unlock_irqrestore(&dev->event_lock, flags);
1354 goto out;
1355 }
1356
1357 e->event.base.type = DRM_EVENT_FLIP_COMPLETE;
1358 e->event.base.length = sizeof e->event;
1359 e->event.user_data = user_data;
1360 e->base.event = &e->event.base;
1361 e->base.file_priv = file_priv;
1362 e->base.destroy = (void (*) (struct drm_pending_event *)) kfree;
1363
1364 out:
1365 return e;
1366 }
1367
destroy_vblank_event(struct drm_device * dev,struct drm_file * file_priv,struct drm_pending_vblank_event * e)1368 static void destroy_vblank_event(struct drm_device *dev,
1369 struct drm_file *file_priv, struct drm_pending_vblank_event *e)
1370 {
1371 unsigned long flags;
1372
1373 spin_lock_irqsave(&dev->event_lock, flags);
1374 file_priv->event_space += sizeof e->event;
1375 spin_unlock_irqrestore(&dev->event_lock, flags);
1376 kfree(e);
1377 }
1378
atomic_set_prop(struct drm_atomic_state * state,struct drm_mode_object * obj,struct drm_property * prop,uint64_t prop_value)1379 static int atomic_set_prop(struct drm_atomic_state *state,
1380 struct drm_mode_object *obj, struct drm_property *prop,
1381 uint64_t prop_value)
1382 {
1383 struct drm_mode_object *ref;
1384 int ret;
1385
1386 if (!drm_property_change_valid_get(prop, prop_value, &ref))
1387 return -EINVAL;
1388
1389 switch (obj->type) {
1390 case DRM_MODE_OBJECT_CONNECTOR: {
1391 struct drm_connector *connector = obj_to_connector(obj);
1392 struct drm_connector_state *connector_state;
1393
1394 connector_state = drm_atomic_get_connector_state(state, connector);
1395 if (IS_ERR(connector_state)) {
1396 ret = PTR_ERR(connector_state);
1397 break;
1398 }
1399
1400 ret = drm_atomic_connector_set_property(connector,
1401 connector_state, prop, prop_value);
1402 break;
1403 }
1404 case DRM_MODE_OBJECT_CRTC: {
1405 struct drm_crtc *crtc = obj_to_crtc(obj);
1406 struct drm_crtc_state *crtc_state;
1407
1408 crtc_state = drm_atomic_get_crtc_state(state, crtc);
1409 if (IS_ERR(crtc_state)) {
1410 ret = PTR_ERR(crtc_state);
1411 break;
1412 }
1413
1414 ret = drm_atomic_crtc_set_property(crtc,
1415 crtc_state, prop, prop_value);
1416 break;
1417 }
1418 case DRM_MODE_OBJECT_PLANE: {
1419 struct drm_plane *plane = obj_to_plane(obj);
1420 struct drm_plane_state *plane_state;
1421
1422 plane_state = drm_atomic_get_plane_state(state, plane);
1423 if (IS_ERR(plane_state)) {
1424 ret = PTR_ERR(plane_state);
1425 break;
1426 }
1427
1428 ret = drm_atomic_plane_set_property(plane,
1429 plane_state, prop, prop_value);
1430 break;
1431 }
1432 default:
1433 ret = -EINVAL;
1434 break;
1435 }
1436
1437 drm_property_change_valid_put(prop, ref);
1438 return ret;
1439 }
1440
1441 /**
1442 * drm_atomic_update_old_fb -- Unset old_fb pointers and set plane->fb pointers.
1443 *
1444 * @dev: drm device to check.
1445 * @plane_mask: plane mask for planes that were updated.
1446 * @ret: return value, can be -EDEADLK for a retry.
1447 *
1448 * Before doing an update plane->old_fb is set to plane->fb,
1449 * but before dropping the locks old_fb needs to be set to NULL
1450 * and plane->fb updated. This is a common operation for each
1451 * atomic update, so this call is split off as a helper.
1452 */
drm_atomic_clean_old_fb(struct drm_device * dev,unsigned plane_mask,int ret)1453 void drm_atomic_clean_old_fb(struct drm_device *dev,
1454 unsigned plane_mask,
1455 int ret)
1456 {
1457 struct drm_plane *plane;
1458
1459 /* if succeeded, fixup legacy plane crtc/fb ptrs before dropping
1460 * locks (ie. while it is still safe to deref plane->state). We
1461 * need to do this here because the driver entry points cannot
1462 * distinguish between legacy and atomic ioctls.
1463 */
1464 drm_for_each_plane_mask(plane, dev, plane_mask) {
1465 if (ret == 0) {
1466 struct drm_framebuffer *new_fb = plane->state->fb;
1467 if (new_fb)
1468 drm_framebuffer_reference(new_fb);
1469 plane->fb = new_fb;
1470 plane->crtc = plane->state->crtc;
1471
1472 if (plane->old_fb)
1473 drm_framebuffer_unreference(plane->old_fb);
1474 }
1475 plane->old_fb = NULL;
1476 }
1477 }
1478 EXPORT_SYMBOL(drm_atomic_clean_old_fb);
1479
drm_mode_atomic_ioctl(struct drm_device * dev,void * data,struct drm_file * file_priv)1480 int drm_mode_atomic_ioctl(struct drm_device *dev,
1481 void *data, struct drm_file *file_priv)
1482 {
1483 struct drm_mode_atomic *arg = data;
1484 uint32_t __user *objs_ptr = (uint32_t __user *)(unsigned long)(arg->objs_ptr);
1485 uint32_t __user *count_props_ptr = (uint32_t __user *)(unsigned long)(arg->count_props_ptr);
1486 uint32_t __user *props_ptr = (uint32_t __user *)(unsigned long)(arg->props_ptr);
1487 uint64_t __user *prop_values_ptr = (uint64_t __user *)(unsigned long)(arg->prop_values_ptr);
1488 unsigned int copied_objs, copied_props;
1489 struct drm_atomic_state *state;
1490 struct drm_modeset_acquire_ctx ctx;
1491 struct drm_plane *plane;
1492 struct drm_crtc *crtc;
1493 struct drm_crtc_state *crtc_state;
1494 unsigned plane_mask;
1495 int ret = 0;
1496 unsigned int i, j;
1497
1498 /* disallow for drivers not supporting atomic: */
1499 if (!drm_core_check_feature(dev, DRIVER_ATOMIC))
1500 return -EINVAL;
1501
1502 /* disallow for userspace that has not enabled atomic cap (even
1503 * though this may be a bit overkill, since legacy userspace
1504 * wouldn't know how to call this ioctl)
1505 */
1506 if (!file_priv->atomic)
1507 return -EINVAL;
1508
1509 if (arg->flags & ~DRM_MODE_ATOMIC_FLAGS)
1510 return -EINVAL;
1511
1512 if (arg->reserved)
1513 return -EINVAL;
1514
1515 if ((arg->flags & DRM_MODE_PAGE_FLIP_ASYNC) &&
1516 !dev->mode_config.async_page_flip)
1517 return -EINVAL;
1518
1519 /* can't test and expect an event at the same time. */
1520 if ((arg->flags & DRM_MODE_ATOMIC_TEST_ONLY) &&
1521 (arg->flags & DRM_MODE_PAGE_FLIP_EVENT))
1522 return -EINVAL;
1523
1524 drm_modeset_acquire_init(&ctx, 0);
1525
1526 state = drm_atomic_state_alloc(dev);
1527 if (!state)
1528 return -ENOMEM;
1529
1530 state->acquire_ctx = &ctx;
1531 state->allow_modeset = !!(arg->flags & DRM_MODE_ATOMIC_ALLOW_MODESET);
1532
1533 retry:
1534 plane_mask = 0;
1535 copied_objs = 0;
1536 copied_props = 0;
1537
1538 for (i = 0; i < arg->count_objs; i++) {
1539 uint32_t obj_id, count_props;
1540 struct drm_mode_object *obj;
1541
1542 if (get_user(obj_id, objs_ptr + copied_objs)) {
1543 ret = -EFAULT;
1544 goto out;
1545 }
1546
1547 obj = drm_mode_object_find(dev, obj_id, DRM_MODE_OBJECT_ANY);
1548 if (!obj || !obj->properties) {
1549 ret = -ENOENT;
1550 goto out;
1551 }
1552
1553 if (get_user(count_props, count_props_ptr + copied_objs)) {
1554 ret = -EFAULT;
1555 goto out;
1556 }
1557
1558 copied_objs++;
1559
1560 for (j = 0; j < count_props; j++) {
1561 uint32_t prop_id;
1562 uint64_t prop_value;
1563 struct drm_property *prop;
1564
1565 if (get_user(prop_id, props_ptr + copied_props)) {
1566 ret = -EFAULT;
1567 goto out;
1568 }
1569
1570 prop = drm_property_find(dev, prop_id);
1571 if (!prop) {
1572 ret = -ENOENT;
1573 goto out;
1574 }
1575
1576 if (copy_from_user(&prop_value,
1577 prop_values_ptr + copied_props,
1578 sizeof(prop_value))) {
1579 ret = -EFAULT;
1580 goto out;
1581 }
1582
1583 ret = atomic_set_prop(state, obj, prop, prop_value);
1584 if (ret)
1585 goto out;
1586
1587 copied_props++;
1588 }
1589
1590 if (obj->type == DRM_MODE_OBJECT_PLANE && count_props &&
1591 !(arg->flags & DRM_MODE_ATOMIC_TEST_ONLY)) {
1592 plane = obj_to_plane(obj);
1593 plane_mask |= (1 << drm_plane_index(plane));
1594 plane->old_fb = plane->fb;
1595 }
1596 }
1597
1598 if (arg->flags & DRM_MODE_PAGE_FLIP_EVENT) {
1599 for_each_crtc_in_state(state, crtc, crtc_state, i) {
1600 struct drm_pending_vblank_event *e;
1601
1602 e = create_vblank_event(dev, file_priv, arg->user_data);
1603 if (!e) {
1604 ret = -ENOMEM;
1605 goto out;
1606 }
1607
1608 crtc_state->event = e;
1609 }
1610 }
1611
1612 if (arg->flags & DRM_MODE_ATOMIC_TEST_ONLY) {
1613 /*
1614 * Unlike commit, check_only does not clean up state.
1615 * Below we call drm_atomic_state_free for it.
1616 */
1617 ret = drm_atomic_check_only(state);
1618 } else if (arg->flags & DRM_MODE_ATOMIC_NONBLOCK) {
1619 ret = drm_atomic_async_commit(state);
1620 } else {
1621 ret = drm_atomic_commit(state);
1622 }
1623
1624 out:
1625 drm_atomic_clean_old_fb(dev, plane_mask, ret);
1626
1627 if (ret && arg->flags & DRM_MODE_PAGE_FLIP_EVENT) {
1628 /*
1629 * TEST_ONLY and PAGE_FLIP_EVENT are mutually exclusive,
1630 * if they weren't, this code should be called on success
1631 * for TEST_ONLY too.
1632 */
1633
1634 for_each_crtc_in_state(state, crtc, crtc_state, i) {
1635 if (!crtc_state->event)
1636 continue;
1637
1638 destroy_vblank_event(dev, file_priv,
1639 crtc_state->event);
1640 }
1641 }
1642
1643 if (ret == -EDEADLK) {
1644 drm_atomic_state_clear(state);
1645 drm_modeset_backoff(&ctx);
1646 goto retry;
1647 }
1648
1649 if (ret || arg->flags & DRM_MODE_ATOMIC_TEST_ONLY)
1650 drm_atomic_state_free(state);
1651
1652 drm_modeset_drop_locks(&ctx);
1653 drm_modeset_acquire_fini(&ctx);
1654
1655 return ret;
1656 }
1657