blob: 3ff1ed7b33dbeb74aa036204f90931958eb5ee23 [file] [log] [blame]
Daniel Vettercc4ceb42014-07-25 21:30:38 +02001/*
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>
Lionel Landwerlin5488dc12016-02-26 17:05:00 +000031#include <drm/drm_mode.h>
Daniel Vettercc4ceb42014-07-25 21:30:38 +020032#include <drm/drm_plane_helper.h>
33
Thierry Redingbe35f942016-04-28 15:19:56 +020034#include "drm_crtc_internal.h"
35
Maarten Lankhorst036ef572015-05-18 10:06:40 +020036/**
37 * drm_atomic_state_default_release -
38 * release memory initialized by drm_atomic_state_init
39 * @state: atomic state
40 *
41 * Free all the memory allocated by drm_atomic_state_init.
42 * This is useful for drivers that subclass the atomic state.
43 */
44void drm_atomic_state_default_release(struct drm_atomic_state *state)
Daniel Vettercc4ceb42014-07-25 21:30:38 +020045{
46 kfree(state->connectors);
47 kfree(state->connector_states);
48 kfree(state->crtcs);
49 kfree(state->crtc_states);
50 kfree(state->planes);
51 kfree(state->plane_states);
Daniel Vettercc4ceb42014-07-25 21:30:38 +020052}
Maarten Lankhorst036ef572015-05-18 10:06:40 +020053EXPORT_SYMBOL(drm_atomic_state_default_release);
Daniel Vettercc4ceb42014-07-25 21:30:38 +020054
55/**
Maarten Lankhorst036ef572015-05-18 10:06:40 +020056 * drm_atomic_state_init - init new atomic state
Daniel Vettercc4ceb42014-07-25 21:30:38 +020057 * @dev: DRM device
Maarten Lankhorst036ef572015-05-18 10:06:40 +020058 * @state: atomic state
Daniel Vettercc4ceb42014-07-25 21:30:38 +020059 *
Maarten Lankhorst036ef572015-05-18 10:06:40 +020060 * Default implementation for filling in a new atomic state.
61 * This is useful for drivers that subclass the atomic state.
Daniel Vettercc4ceb42014-07-25 21:30:38 +020062 */
Maarten Lankhorst036ef572015-05-18 10:06:40 +020063int
64drm_atomic_state_init(struct drm_device *dev, struct drm_atomic_state *state)
Daniel Vettercc4ceb42014-07-25 21:30:38 +020065{
Rob Clarkd34f20d2014-12-18 16:01:56 -050066 /* TODO legacy paths should maybe do a better job about
67 * setting this appropriately?
68 */
69 state->allow_modeset = true;
70
Daniel Vettercc4ceb42014-07-25 21:30:38 +020071 state->crtcs = kcalloc(dev->mode_config.num_crtc,
72 sizeof(*state->crtcs), GFP_KERNEL);
73 if (!state->crtcs)
74 goto fail;
75 state->crtc_states = kcalloc(dev->mode_config.num_crtc,
76 sizeof(*state->crtc_states), GFP_KERNEL);
77 if (!state->crtc_states)
78 goto fail;
79 state->planes = kcalloc(dev->mode_config.num_total_plane,
80 sizeof(*state->planes), GFP_KERNEL);
81 if (!state->planes)
82 goto fail;
83 state->plane_states = kcalloc(dev->mode_config.num_total_plane,
84 sizeof(*state->plane_states), GFP_KERNEL);
85 if (!state->plane_states)
86 goto fail;
Daniel Vettercc4ceb42014-07-25 21:30:38 +020087
88 state->dev = dev;
89
Maarten Lankhorst036ef572015-05-18 10:06:40 +020090 DRM_DEBUG_ATOMIC("Allocated atomic state %p\n", state);
Daniel Vettercc4ceb42014-07-25 21:30:38 +020091
Maarten Lankhorst036ef572015-05-18 10:06:40 +020092 return 0;
Daniel Vettercc4ceb42014-07-25 21:30:38 +020093fail:
Maarten Lankhorst036ef572015-05-18 10:06:40 +020094 drm_atomic_state_default_release(state);
95 return -ENOMEM;
96}
97EXPORT_SYMBOL(drm_atomic_state_init);
Daniel Vettercc4ceb42014-07-25 21:30:38 +020098
Maarten Lankhorst036ef572015-05-18 10:06:40 +020099/**
100 * drm_atomic_state_alloc - allocate atomic state
101 * @dev: DRM device
102 *
103 * This allocates an empty atomic state to track updates.
104 */
105struct drm_atomic_state *
106drm_atomic_state_alloc(struct drm_device *dev)
107{
108 struct drm_mode_config *config = &dev->mode_config;
109 struct drm_atomic_state *state;
110
111 if (!config->funcs->atomic_state_alloc) {
112 state = kzalloc(sizeof(*state), GFP_KERNEL);
113 if (!state)
114 return NULL;
115 if (drm_atomic_state_init(dev, state) < 0) {
116 kfree(state);
117 return NULL;
118 }
119 return state;
120 }
121
122 return config->funcs->atomic_state_alloc(dev);
Daniel Vettercc4ceb42014-07-25 21:30:38 +0200123}
124EXPORT_SYMBOL(drm_atomic_state_alloc);
125
126/**
Maarten Lankhorst036ef572015-05-18 10:06:40 +0200127 * drm_atomic_state_default_clear - clear base atomic state
Daniel Vettercc4ceb42014-07-25 21:30:38 +0200128 * @state: atomic state
129 *
Maarten Lankhorst036ef572015-05-18 10:06:40 +0200130 * Default implementation for clearing atomic state.
131 * This is useful for drivers that subclass the atomic state.
Daniel Vettercc4ceb42014-07-25 21:30:38 +0200132 */
Maarten Lankhorst036ef572015-05-18 10:06:40 +0200133void drm_atomic_state_default_clear(struct drm_atomic_state *state)
Daniel Vettercc4ceb42014-07-25 21:30:38 +0200134{
135 struct drm_device *dev = state->dev;
Daniel Vetter6f75cea2014-11-19 18:38:07 +0100136 struct drm_mode_config *config = &dev->mode_config;
Daniel Vettercc4ceb42014-07-25 21:30:38 +0200137 int i;
138
Daniel Vetter17a38d92015-02-22 12:24:16 +0100139 DRM_DEBUG_ATOMIC("Clearing atomic state %p\n", state);
Daniel Vettercc4ceb42014-07-25 21:30:38 +0200140
Daniel Vetterf52b69f12014-11-19 18:38:08 +0100141 for (i = 0; i < state->num_connector; i++) {
Daniel Vettercc4ceb42014-07-25 21:30:38 +0200142 struct drm_connector *connector = state->connectors[i];
143
144 if (!connector)
145 continue;
146
Dave Airlied2307de2016-04-27 11:27:39 +1000147 connector->funcs->atomic_destroy_state(connector,
Daniel Vettercc4ceb42014-07-25 21:30:38 +0200148 state->connector_states[i]);
Ander Conselvan de Oliveira8a5c0bd2015-03-30 10:41:19 +0300149 state->connectors[i] = NULL;
Ander Conselvan de Oliveira94692442015-01-23 09:27:59 +0200150 state->connector_states[i] = NULL;
Dave Airlieb164d312016-04-27 11:10:09 +1000151 drm_connector_unreference(connector);
Daniel Vettercc4ceb42014-07-25 21:30:38 +0200152 }
153
Daniel Vetter6f75cea2014-11-19 18:38:07 +0100154 for (i = 0; i < config->num_crtc; i++) {
Daniel Vettercc4ceb42014-07-25 21:30:38 +0200155 struct drm_crtc *crtc = state->crtcs[i];
156
157 if (!crtc)
158 continue;
159
160 crtc->funcs->atomic_destroy_state(crtc,
161 state->crtc_states[i]);
Ander Conselvan de Oliveira8a5c0bd2015-03-30 10:41:19 +0300162 state->crtcs[i] = NULL;
Ander Conselvan de Oliveira94692442015-01-23 09:27:59 +0200163 state->crtc_states[i] = NULL;
Daniel Vettercc4ceb42014-07-25 21:30:38 +0200164 }
165
Daniel Vetter6f75cea2014-11-19 18:38:07 +0100166 for (i = 0; i < config->num_total_plane; i++) {
Daniel Vettercc4ceb42014-07-25 21:30:38 +0200167 struct drm_plane *plane = state->planes[i];
168
169 if (!plane)
170 continue;
171
172 plane->funcs->atomic_destroy_state(plane,
173 state->plane_states[i]);
Ander Conselvan de Oliveira8a5c0bd2015-03-30 10:41:19 +0300174 state->planes[i] = NULL;
Ander Conselvan de Oliveira94692442015-01-23 09:27:59 +0200175 state->plane_states[i] = NULL;
Daniel Vettercc4ceb42014-07-25 21:30:38 +0200176 }
177}
Maarten Lankhorst036ef572015-05-18 10:06:40 +0200178EXPORT_SYMBOL(drm_atomic_state_default_clear);
179
180/**
181 * drm_atomic_state_clear - clear state object
182 * @state: atomic state
183 *
184 * When the w/w mutex algorithm detects a deadlock we need to back off and drop
185 * all locks. So someone else could sneak in and change the current modeset
186 * configuration. Which means that all the state assembled in @state is no
187 * longer an atomic update to the current state, but to some arbitrary earlier
188 * state. Which could break assumptions the driver's ->atomic_check likely
189 * relies on.
190 *
191 * Hence we must clear all cached state and completely start over, using this
192 * function.
193 */
194void drm_atomic_state_clear(struct drm_atomic_state *state)
195{
196 struct drm_device *dev = state->dev;
197 struct drm_mode_config *config = &dev->mode_config;
198
199 if (config->funcs->atomic_state_clear)
200 config->funcs->atomic_state_clear(state);
201 else
202 drm_atomic_state_default_clear(state);
203}
Daniel Vettercc4ceb42014-07-25 21:30:38 +0200204EXPORT_SYMBOL(drm_atomic_state_clear);
205
206/**
207 * drm_atomic_state_free - free all memory for an atomic state
208 * @state: atomic state to deallocate
209 *
210 * This frees all memory associated with an atomic state, including all the
211 * per-object state for planes, crtcs and connectors.
212 */
213void drm_atomic_state_free(struct drm_atomic_state *state)
214{
Maarten Lankhorst036ef572015-05-18 10:06:40 +0200215 struct drm_device *dev;
216 struct drm_mode_config *config;
217
Ander Conselvan de Oliveiraa0211bb2015-03-30 14:05:43 +0300218 if (!state)
219 return;
220
Maarten Lankhorst036ef572015-05-18 10:06:40 +0200221 dev = state->dev;
222 config = &dev->mode_config;
223
Daniel Vettercc4ceb42014-07-25 21:30:38 +0200224 drm_atomic_state_clear(state);
225
Daniel Vetter17a38d92015-02-22 12:24:16 +0100226 DRM_DEBUG_ATOMIC("Freeing atomic state %p\n", state);
Daniel Vettercc4ceb42014-07-25 21:30:38 +0200227
Maarten Lankhorst036ef572015-05-18 10:06:40 +0200228 if (config->funcs->atomic_state_free) {
229 config->funcs->atomic_state_free(state);
230 } else {
231 drm_atomic_state_default_release(state);
232 kfree(state);
233 }
Daniel Vettercc4ceb42014-07-25 21:30:38 +0200234}
235EXPORT_SYMBOL(drm_atomic_state_free);
236
237/**
238 * drm_atomic_get_crtc_state - get crtc state
239 * @state: global atomic state object
240 * @crtc: crtc to get state object for
241 *
242 * This function returns the crtc state for the given crtc, allocating it if
243 * needed. It will also grab the relevant crtc lock to make sure that the state
244 * is consistent.
245 *
246 * Returns:
247 *
248 * Either the allocated state or the error code encoded into the pointer. When
249 * the error is EDEADLK then the w/w mutex code has detected a deadlock and the
250 * entire atomic sequence must be restarted. All other errors are fatal.
251 */
252struct drm_crtc_state *
253drm_atomic_get_crtc_state(struct drm_atomic_state *state,
254 struct drm_crtc *crtc)
255{
Maarten Lankhorst1b26a5e2015-05-13 10:37:25 +0200256 int ret, index = drm_crtc_index(crtc);
Daniel Vettercc4ceb42014-07-25 21:30:38 +0200257 struct drm_crtc_state *crtc_state;
258
Maarten Lankhorst7f4eaa82016-05-03 11:12:31 +0200259 WARN_ON(!state->acquire_ctx);
260
Maarten Lankhorst1b26a5e2015-05-13 10:37:25 +0200261 crtc_state = drm_atomic_get_existing_crtc_state(state, crtc);
262 if (crtc_state)
263 return crtc_state;
Daniel Vettercc4ceb42014-07-25 21:30:38 +0200264
265 ret = drm_modeset_lock(&crtc->mutex, state->acquire_ctx);
266 if (ret)
267 return ERR_PTR(ret);
268
269 crtc_state = crtc->funcs->atomic_duplicate_state(crtc);
270 if (!crtc_state)
271 return ERR_PTR(-ENOMEM);
272
273 state->crtc_states[index] = crtc_state;
274 state->crtcs[index] = crtc;
275 crtc_state->state = state;
276
Ville Syrjäläfa3ab4c2015-12-08 18:41:53 +0200277 DRM_DEBUG_ATOMIC("Added [CRTC:%d:%s] %p state to %p\n",
278 crtc->base.id, crtc->name, crtc_state, state);
Daniel Vettercc4ceb42014-07-25 21:30:38 +0200279
280 return crtc_state;
281}
282EXPORT_SYMBOL(drm_atomic_get_crtc_state);
283
284/**
Daniel Stone819364d2015-05-26 14:36:48 +0100285 * drm_atomic_set_mode_for_crtc - set mode for CRTC
286 * @state: the CRTC whose incoming state to update
287 * @mode: kernel-internal mode to use for the CRTC, or NULL to disable
288 *
289 * Set a mode (originating from the kernel) on the desired CRTC state. Does
290 * not change any other state properties, including enable, active, or
291 * mode_changed.
292 *
293 * RETURNS:
294 * Zero on success, error code on failure. Cannot return -EDEADLK.
295 */
296int drm_atomic_set_mode_for_crtc(struct drm_crtc_state *state,
297 struct drm_display_mode *mode)
298{
Daniel Stone99cf4a22015-05-25 19:11:51 +0100299 struct drm_mode_modeinfo umode;
300
Daniel Stone819364d2015-05-26 14:36:48 +0100301 /* Early return for no change. */
302 if (mode && memcmp(&state->mode, mode, sizeof(*mode)) == 0)
303 return 0;
304
Markus Elfring5f911902015-11-06 12:03:46 +0100305 drm_property_unreference_blob(state->mode_blob);
Daniel Stone99cf4a22015-05-25 19:11:51 +0100306 state->mode_blob = NULL;
307
Daniel Stone819364d2015-05-26 14:36:48 +0100308 if (mode) {
Daniel Stone99cf4a22015-05-25 19:11:51 +0100309 drm_mode_convert_to_umode(&umode, mode);
310 state->mode_blob =
311 drm_property_create_blob(state->crtc->dev,
312 sizeof(umode),
313 &umode);
314 if (IS_ERR(state->mode_blob))
315 return PTR_ERR(state->mode_blob);
316
Daniel Stone819364d2015-05-26 14:36:48 +0100317 drm_mode_copy(&state->mode, mode);
318 state->enable = true;
319 DRM_DEBUG_ATOMIC("Set [MODE:%s] for CRTC state %p\n",
320 mode->name, state);
321 } else {
322 memset(&state->mode, 0, sizeof(state->mode));
323 state->enable = false;
324 DRM_DEBUG_ATOMIC("Set [NOMODE] for CRTC state %p\n",
325 state);
326 }
327
328 return 0;
329}
330EXPORT_SYMBOL(drm_atomic_set_mode_for_crtc);
331
Daniel Stone819364d2015-05-26 14:36:48 +0100332/**
Daniel Stone955f3c32015-05-25 19:11:52 +0100333 * drm_atomic_set_mode_prop_for_crtc - set mode for CRTC
334 * @state: the CRTC whose incoming state to update
335 * @blob: pointer to blob property to use for mode
336 *
337 * Set a mode (originating from a blob property) on the desired CRTC state.
338 * This function will take a reference on the blob property for the CRTC state,
339 * and release the reference held on the state's existing mode property, if any
340 * was set.
341 *
342 * RETURNS:
343 * Zero on success, error code on failure. Cannot return -EDEADLK.
344 */
345int drm_atomic_set_mode_prop_for_crtc(struct drm_crtc_state *state,
346 struct drm_property_blob *blob)
347{
348 if (blob == state->mode_blob)
349 return 0;
350
Markus Elfring5f911902015-11-06 12:03:46 +0100351 drm_property_unreference_blob(state->mode_blob);
Daniel Stone955f3c32015-05-25 19:11:52 +0100352 state->mode_blob = NULL;
353
354 if (blob) {
355 if (blob->length != sizeof(struct drm_mode_modeinfo) ||
356 drm_mode_convert_umode(&state->mode,
357 (const struct drm_mode_modeinfo *)
358 blob->data))
359 return -EINVAL;
360
361 state->mode_blob = drm_property_reference_blob(blob);
362 state->enable = true;
363 DRM_DEBUG_ATOMIC("Set [MODE:%s] for CRTC state %p\n",
364 state->mode.name, state);
365 } else {
366 memset(&state->mode, 0, sizeof(state->mode));
367 state->enable = false;
368 DRM_DEBUG_ATOMIC("Set [NOMODE] for CRTC state %p\n",
369 state);
370 }
371
372 return 0;
373}
374EXPORT_SYMBOL(drm_atomic_set_mode_prop_for_crtc);
375
376/**
Lionel Landwerlin5488dc12016-02-26 17:05:00 +0000377 * drm_atomic_replace_property_blob - replace a blob property
378 * @blob: a pointer to the member blob to be replaced
379 * @new_blob: the new blob to replace with
Lionel Landwerlin5488dc12016-02-26 17:05:00 +0000380 * @replaced: whether the blob has been replaced
381 *
382 * RETURNS:
383 * Zero on success, error code on failure
384 */
385static void
386drm_atomic_replace_property_blob(struct drm_property_blob **blob,
387 struct drm_property_blob *new_blob,
388 bool *replaced)
389{
390 struct drm_property_blob *old_blob = *blob;
391
392 if (old_blob == new_blob)
393 return;
394
395 if (old_blob)
396 drm_property_unreference_blob(old_blob);
397 if (new_blob)
398 drm_property_reference_blob(new_blob);
399 *blob = new_blob;
400 *replaced = true;
401
402 return;
403}
404
405static int
406drm_atomic_replace_property_blob_from_id(struct drm_crtc *crtc,
407 struct drm_property_blob **blob,
408 uint64_t blob_id,
409 ssize_t expected_size,
410 bool *replaced)
411{
412 struct drm_device *dev = crtc->dev;
413 struct drm_property_blob *new_blob = NULL;
414
415 if (blob_id != 0) {
416 new_blob = drm_property_lookup_blob(dev, blob_id);
417 if (new_blob == NULL)
418 return -EINVAL;
419 if (expected_size > 0 && expected_size != new_blob->length)
420 return -EINVAL;
421 }
422
423 drm_atomic_replace_property_blob(blob, new_blob, replaced);
424
425 return 0;
426}
427
428/**
Rob Clark40ecc692014-12-18 16:01:46 -0500429 * drm_atomic_crtc_set_property - set property on CRTC
430 * @crtc: the drm CRTC to set a property on
431 * @state: the state object to update with the new property value
432 * @property: the property to set
433 * @val: the new property value
434 *
435 * Use this instead of calling crtc->atomic_set_property directly.
436 * This function handles generic/core properties and calls out to
437 * driver's ->atomic_set_property() for driver properties. To ensure
438 * consistent behavior you must call this function rather than the
439 * driver hook directly.
440 *
441 * RETURNS:
442 * Zero on success, error code on failure
443 */
444int drm_atomic_crtc_set_property(struct drm_crtc *crtc,
445 struct drm_crtc_state *state, struct drm_property *property,
446 uint64_t val)
447{
Daniel Vettereab3bbe2015-01-22 16:36:21 +0100448 struct drm_device *dev = crtc->dev;
449 struct drm_mode_config *config = &dev->mode_config;
Lionel Landwerlin5488dc12016-02-26 17:05:00 +0000450 bool replaced = false;
Daniel Stone955f3c32015-05-25 19:11:52 +0100451 int ret;
Daniel Vettereab3bbe2015-01-22 16:36:21 +0100452
Daniel Stone27798362015-03-19 04:33:26 +0000453 if (property == config->prop_active)
Daniel Vettereab3bbe2015-01-22 16:36:21 +0100454 state->active = val;
Daniel Stone955f3c32015-05-25 19:11:52 +0100455 else if (property == config->prop_mode_id) {
456 struct drm_property_blob *mode =
457 drm_property_lookup_blob(dev, val);
458 ret = drm_atomic_set_mode_prop_for_crtc(state, mode);
Markus Elfring5f911902015-11-06 12:03:46 +0100459 drm_property_unreference_blob(mode);
Daniel Stone955f3c32015-05-25 19:11:52 +0100460 return ret;
Lionel Landwerlin5488dc12016-02-26 17:05:00 +0000461 } else if (property == config->degamma_lut_property) {
462 ret = drm_atomic_replace_property_blob_from_id(crtc,
463 &state->degamma_lut,
464 val,
465 -1,
466 &replaced);
467 state->color_mgmt_changed = replaced;
468 return ret;
469 } else if (property == config->ctm_property) {
470 ret = drm_atomic_replace_property_blob_from_id(crtc,
471 &state->ctm,
472 val,
473 sizeof(struct drm_color_ctm),
474 &replaced);
475 state->color_mgmt_changed = replaced;
476 return ret;
477 } else if (property == config->gamma_lut_property) {
478 ret = drm_atomic_replace_property_blob_from_id(crtc,
479 &state->gamma_lut,
480 val,
481 -1,
482 &replaced);
483 state->color_mgmt_changed = replaced;
484 return ret;
485 } else if (crtc->funcs->atomic_set_property)
Rob Clark40ecc692014-12-18 16:01:46 -0500486 return crtc->funcs->atomic_set_property(crtc, state, property, val);
Daniel Stone27798362015-03-19 04:33:26 +0000487 else
488 return -EINVAL;
489
490 return 0;
Rob Clark40ecc692014-12-18 16:01:46 -0500491}
492EXPORT_SYMBOL(drm_atomic_crtc_set_property);
493
Daniel Vetterc0714fc2015-12-04 09:45:57 +0100494/**
495 * drm_atomic_crtc_get_property - get property value from CRTC state
496 * @crtc: the drm CRTC to set a property on
497 * @state: the state object to get the property value from
498 * @property: the property to set
499 * @val: return location for the property value
500 *
Rob Clarkac9c9252014-12-18 16:01:47 -0500501 * This function handles generic/core properties and calls out to
502 * driver's ->atomic_get_property() for driver properties. To ensure
503 * consistent behavior you must call this function rather than the
504 * driver hook directly.
Daniel Vetterc0714fc2015-12-04 09:45:57 +0100505 *
506 * RETURNS:
507 * Zero on success, error code on failure
Rob Clarkac9c9252014-12-18 16:01:47 -0500508 */
Geliang Tangbf22f3b2015-09-24 03:01:03 -0700509static int
510drm_atomic_crtc_get_property(struct drm_crtc *crtc,
Rob Clarkac9c9252014-12-18 16:01:47 -0500511 const struct drm_crtc_state *state,
512 struct drm_property *property, uint64_t *val)
513{
Daniel Stone8f164ce2015-03-19 04:33:25 +0000514 struct drm_device *dev = crtc->dev;
515 struct drm_mode_config *config = &dev->mode_config;
516
517 if (property == config->prop_active)
518 *val = state->active;
Daniel Stone955f3c32015-05-25 19:11:52 +0100519 else if (property == config->prop_mode_id)
520 *val = (state->mode_blob) ? state->mode_blob->base.id : 0;
Lionel Landwerlin5488dc12016-02-26 17:05:00 +0000521 else if (property == config->degamma_lut_property)
522 *val = (state->degamma_lut) ? state->degamma_lut->base.id : 0;
523 else if (property == config->ctm_property)
524 *val = (state->ctm) ? state->ctm->base.id : 0;
525 else if (property == config->gamma_lut_property)
526 *val = (state->gamma_lut) ? state->gamma_lut->base.id : 0;
Daniel Stone8f164ce2015-03-19 04:33:25 +0000527 else if (crtc->funcs->atomic_get_property)
Rob Clarkac9c9252014-12-18 16:01:47 -0500528 return crtc->funcs->atomic_get_property(crtc, state, property, val);
Daniel Stone8f164ce2015-03-19 04:33:25 +0000529 else
530 return -EINVAL;
531
532 return 0;
Rob Clarkac9c9252014-12-18 16:01:47 -0500533}
Rob Clarkac9c9252014-12-18 16:01:47 -0500534
535/**
Rob Clark5e743732014-12-18 16:01:51 -0500536 * drm_atomic_crtc_check - check crtc state
537 * @crtc: crtc to check
538 * @state: crtc state to check
539 *
540 * Provides core sanity checks for crtc state.
541 *
542 * RETURNS:
543 * Zero on success, error code on failure
544 */
545static int drm_atomic_crtc_check(struct drm_crtc *crtc,
546 struct drm_crtc_state *state)
547{
548 /* NOTE: we explicitly don't enforce constraints such as primary
549 * layer covering entire screen, since that is something we want
550 * to allow (on hw that supports it). For hw that does not, it
551 * should be checked in driver's crtc->atomic_check() vfunc.
552 *
553 * TODO: Add generic modeset state checks once we support those.
554 */
Daniel Vettereab3bbe2015-01-22 16:36:21 +0100555
556 if (state->active && !state->enable) {
Ville Syrjäläfa3ab4c2015-12-08 18:41:53 +0200557 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] active without enabled\n",
558 crtc->base.id, crtc->name);
Daniel Vettereab3bbe2015-01-22 16:36:21 +0100559 return -EINVAL;
560 }
561
Daniel Stone99cf4a22015-05-25 19:11:51 +0100562 /* The state->enable vs. state->mode_blob checks can be WARN_ON,
563 * as this is a kernel-internal detail that userspace should never
564 * be able to trigger. */
565 if (drm_core_check_feature(crtc->dev, DRIVER_ATOMIC) &&
566 WARN_ON(state->enable && !state->mode_blob)) {
Ville Syrjäläfa3ab4c2015-12-08 18:41:53 +0200567 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] enabled without mode blob\n",
568 crtc->base.id, crtc->name);
Daniel Stone99cf4a22015-05-25 19:11:51 +0100569 return -EINVAL;
570 }
571
572 if (drm_core_check_feature(crtc->dev, DRIVER_ATOMIC) &&
573 WARN_ON(!state->enable && state->mode_blob)) {
Ville Syrjäläfa3ab4c2015-12-08 18:41:53 +0200574 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] disabled with mode blob\n",
575 crtc->base.id, crtc->name);
Daniel Stone99cf4a22015-05-25 19:11:51 +0100576 return -EINVAL;
577 }
578
Daniel Vetter4cba6852015-12-08 09:49:20 +0100579 /*
580 * Reject event generation for when a CRTC is off and stays off.
581 * It wouldn't be hard to implement this, but userspace has a track
582 * record of happily burning through 100% cpu (or worse, crash) when the
583 * display pipe is suspended. To avoid all that fun just reject updates
584 * that ask for events since likely that indicates a bug in the
585 * compositor's drawing loop. This is consistent with the vblank IOCTL
586 * and legacy page_flip IOCTL which also reject service on a disabled
587 * pipe.
588 */
589 if (state->event && !state->active && !crtc->state->active) {
590 DRM_DEBUG_ATOMIC("[CRTC:%d] requesting event but off\n",
591 crtc->base.id);
592 return -EINVAL;
593 }
594
Rob Clark5e743732014-12-18 16:01:51 -0500595 return 0;
596}
597
598/**
Daniel Vettercc4ceb42014-07-25 21:30:38 +0200599 * drm_atomic_get_plane_state - get plane state
600 * @state: global atomic state object
601 * @plane: plane to get state object for
602 *
603 * This function returns the plane state for the given plane, allocating it if
604 * needed. It will also grab the relevant plane lock to make sure that the state
605 * is consistent.
606 *
607 * Returns:
608 *
609 * Either the allocated state or the error code encoded into the pointer. When
610 * the error is EDEADLK then the w/w mutex code has detected a deadlock and the
611 * entire atomic sequence must be restarted. All other errors are fatal.
612 */
613struct drm_plane_state *
614drm_atomic_get_plane_state(struct drm_atomic_state *state,
615 struct drm_plane *plane)
616{
Maarten Lankhorst1b26a5e2015-05-13 10:37:25 +0200617 int ret, index = drm_plane_index(plane);
Daniel Vettercc4ceb42014-07-25 21:30:38 +0200618 struct drm_plane_state *plane_state;
619
Maarten Lankhorst7f4eaa82016-05-03 11:12:31 +0200620 WARN_ON(!state->acquire_ctx);
621
Maarten Lankhorst1b26a5e2015-05-13 10:37:25 +0200622 plane_state = drm_atomic_get_existing_plane_state(state, plane);
623 if (plane_state)
624 return plane_state;
Daniel Vettercc4ceb42014-07-25 21:30:38 +0200625
Daniel Vetter4d02e2d2014-11-11 10:12:00 +0100626 ret = drm_modeset_lock(&plane->mutex, state->acquire_ctx);
Daniel Vettercc4ceb42014-07-25 21:30:38 +0200627 if (ret)
628 return ERR_PTR(ret);
629
630 plane_state = plane->funcs->atomic_duplicate_state(plane);
631 if (!plane_state)
632 return ERR_PTR(-ENOMEM);
633
634 state->plane_states[index] = plane_state;
635 state->planes[index] = plane;
636 plane_state->state = state;
637
Ville Syrjälä9f4c97a2015-12-08 18:41:54 +0200638 DRM_DEBUG_ATOMIC("Added [PLANE:%d:%s] %p state to %p\n",
639 plane->base.id, plane->name, plane_state, state);
Daniel Vettercc4ceb42014-07-25 21:30:38 +0200640
641 if (plane_state->crtc) {
642 struct drm_crtc_state *crtc_state;
643
644 crtc_state = drm_atomic_get_crtc_state(state,
645 plane_state->crtc);
646 if (IS_ERR(crtc_state))
647 return ERR_CAST(crtc_state);
648 }
649
650 return plane_state;
651}
652EXPORT_SYMBOL(drm_atomic_get_plane_state);
653
654/**
Rob Clark40ecc692014-12-18 16:01:46 -0500655 * drm_atomic_plane_set_property - set property on plane
656 * @plane: the drm plane to set a property on
657 * @state: the state object to update with the new property value
658 * @property: the property to set
659 * @val: the new property value
660 *
661 * Use this instead of calling plane->atomic_set_property directly.
662 * This function handles generic/core properties and calls out to
663 * driver's ->atomic_set_property() for driver properties. To ensure
664 * consistent behavior you must call this function rather than the
665 * driver hook directly.
666 *
667 * RETURNS:
668 * Zero on success, error code on failure
669 */
670int drm_atomic_plane_set_property(struct drm_plane *plane,
671 struct drm_plane_state *state, struct drm_property *property,
672 uint64_t val)
673{
Rob Clark6b4959f2014-12-18 16:01:53 -0500674 struct drm_device *dev = plane->dev;
675 struct drm_mode_config *config = &dev->mode_config;
676
677 if (property == config->prop_fb_id) {
678 struct drm_framebuffer *fb = drm_framebuffer_lookup(dev, val);
679 drm_atomic_set_fb_for_plane(state, fb);
680 if (fb)
681 drm_framebuffer_unreference(fb);
682 } else if (property == config->prop_crtc_id) {
683 struct drm_crtc *crtc = drm_crtc_find(dev, val);
684 return drm_atomic_set_crtc_for_plane(state, crtc);
685 } else if (property == config->prop_crtc_x) {
686 state->crtc_x = U642I64(val);
687 } else if (property == config->prop_crtc_y) {
688 state->crtc_y = U642I64(val);
689 } else if (property == config->prop_crtc_w) {
690 state->crtc_w = val;
691 } else if (property == config->prop_crtc_h) {
692 state->crtc_h = val;
693 } else if (property == config->prop_src_x) {
694 state->src_x = val;
695 } else if (property == config->prop_src_y) {
696 state->src_y = val;
697 } else if (property == config->prop_src_w) {
698 state->src_w = val;
699 } else if (property == config->prop_src_h) {
700 state->src_h = val;
Matt Roper1da30622015-01-21 16:35:40 -0800701 } else if (property == config->rotation_property) {
702 state->rotation = val;
Rob Clark6b4959f2014-12-18 16:01:53 -0500703 } else if (plane->funcs->atomic_set_property) {
704 return plane->funcs->atomic_set_property(plane, state,
705 property, val);
706 } else {
707 return -EINVAL;
708 }
709
710 return 0;
Rob Clark40ecc692014-12-18 16:01:46 -0500711}
712EXPORT_SYMBOL(drm_atomic_plane_set_property);
713
Daniel Vetterc0714fc2015-12-04 09:45:57 +0100714/**
715 * drm_atomic_plane_get_property - get property value from plane state
716 * @plane: the drm plane to set a property on
717 * @state: the state object to get the property value from
718 * @property: the property to set
719 * @val: return location for the property value
720 *
Rob Clarkac9c9252014-12-18 16:01:47 -0500721 * This function handles generic/core properties and calls out to
722 * driver's ->atomic_get_property() for driver properties. To ensure
723 * consistent behavior you must call this function rather than the
724 * driver hook directly.
Daniel Vetterc0714fc2015-12-04 09:45:57 +0100725 *
726 * RETURNS:
727 * Zero on success, error code on failure
Rob Clarkac9c9252014-12-18 16:01:47 -0500728 */
Daniel Vettera97df1c2014-12-18 22:49:02 +0100729static int
730drm_atomic_plane_get_property(struct drm_plane *plane,
Rob Clarkac9c9252014-12-18 16:01:47 -0500731 const struct drm_plane_state *state,
732 struct drm_property *property, uint64_t *val)
733{
Rob Clark6b4959f2014-12-18 16:01:53 -0500734 struct drm_device *dev = plane->dev;
735 struct drm_mode_config *config = &dev->mode_config;
736
737 if (property == config->prop_fb_id) {
738 *val = (state->fb) ? state->fb->base.id : 0;
739 } else if (property == config->prop_crtc_id) {
740 *val = (state->crtc) ? state->crtc->base.id : 0;
741 } else if (property == config->prop_crtc_x) {
742 *val = I642U64(state->crtc_x);
743 } else if (property == config->prop_crtc_y) {
744 *val = I642U64(state->crtc_y);
745 } else if (property == config->prop_crtc_w) {
746 *val = state->crtc_w;
747 } else if (property == config->prop_crtc_h) {
748 *val = state->crtc_h;
749 } else if (property == config->prop_src_x) {
750 *val = state->src_x;
751 } else if (property == config->prop_src_y) {
752 *val = state->src_y;
753 } else if (property == config->prop_src_w) {
754 *val = state->src_w;
755 } else if (property == config->prop_src_h) {
756 *val = state->src_h;
Tvrtko Ursulin4cda09c2015-02-26 13:49:17 +0000757 } else if (property == config->rotation_property) {
758 *val = state->rotation;
Rob Clark6b4959f2014-12-18 16:01:53 -0500759 } else if (plane->funcs->atomic_get_property) {
Rob Clarkac9c9252014-12-18 16:01:47 -0500760 return plane->funcs->atomic_get_property(plane, state, property, val);
Rob Clark6b4959f2014-12-18 16:01:53 -0500761 } else {
762 return -EINVAL;
763 }
764
765 return 0;
Rob Clarkac9c9252014-12-18 16:01:47 -0500766}
Rob Clarkac9c9252014-12-18 16:01:47 -0500767
Daniel Vetterf8aeb412015-08-26 21:49:42 +0200768static bool
769plane_switching_crtc(struct drm_atomic_state *state,
770 struct drm_plane *plane,
771 struct drm_plane_state *plane_state)
772{
773 if (!plane->state->crtc || !plane_state->crtc)
774 return false;
775
776 if (plane->state->crtc == plane_state->crtc)
777 return false;
778
779 /* This could be refined, but currently there's no helper or driver code
780 * to implement direct switching of active planes nor userspace to take
781 * advantage of more direct plane switching without the intermediate
782 * full OFF state.
783 */
784 return true;
785}
786
Rob Clarkac9c9252014-12-18 16:01:47 -0500787/**
Rob Clark5e743732014-12-18 16:01:51 -0500788 * drm_atomic_plane_check - check plane state
789 * @plane: plane to check
790 * @state: plane state to check
791 *
792 * Provides core sanity checks for plane state.
793 *
794 * RETURNS:
795 * Zero on success, error code on failure
796 */
797static int drm_atomic_plane_check(struct drm_plane *plane,
798 struct drm_plane_state *state)
799{
800 unsigned int fb_width, fb_height;
Laurent Pinchartead86102015-03-05 02:25:43 +0200801 int ret;
Rob Clark5e743732014-12-18 16:01:51 -0500802
803 /* either *both* CRTC and FB must be set, or neither */
804 if (WARN_ON(state->crtc && !state->fb)) {
Daniel Vetter17a38d92015-02-22 12:24:16 +0100805 DRM_DEBUG_ATOMIC("CRTC set but no FB\n");
Rob Clark5e743732014-12-18 16:01:51 -0500806 return -EINVAL;
807 } else if (WARN_ON(state->fb && !state->crtc)) {
Daniel Vetter17a38d92015-02-22 12:24:16 +0100808 DRM_DEBUG_ATOMIC("FB set but no CRTC\n");
Rob Clark5e743732014-12-18 16:01:51 -0500809 return -EINVAL;
810 }
811
812 /* if disabled, we don't care about the rest of the state: */
813 if (!state->crtc)
814 return 0;
815
816 /* Check whether this plane is usable on this CRTC */
817 if (!(plane->possible_crtcs & drm_crtc_mask(state->crtc))) {
Daniel Vetter17a38d92015-02-22 12:24:16 +0100818 DRM_DEBUG_ATOMIC("Invalid crtc for plane\n");
Rob Clark5e743732014-12-18 16:01:51 -0500819 return -EINVAL;
820 }
821
822 /* Check whether this plane supports the fb pixel format. */
Laurent Pinchartead86102015-03-05 02:25:43 +0200823 ret = drm_plane_check_pixel_format(plane, state->fb->pixel_format);
824 if (ret) {
Daniel Vetter17a38d92015-02-22 12:24:16 +0100825 DRM_DEBUG_ATOMIC("Invalid pixel format %s\n",
826 drm_get_format_name(state->fb->pixel_format));
Laurent Pinchartead86102015-03-05 02:25:43 +0200827 return ret;
Rob Clark5e743732014-12-18 16:01:51 -0500828 }
829
830 /* Give drivers some help against integer overflows */
831 if (state->crtc_w > INT_MAX ||
832 state->crtc_x > INT_MAX - (int32_t) state->crtc_w ||
833 state->crtc_h > INT_MAX ||
834 state->crtc_y > INT_MAX - (int32_t) state->crtc_h) {
Daniel Vetter17a38d92015-02-22 12:24:16 +0100835 DRM_DEBUG_ATOMIC("Invalid CRTC coordinates %ux%u+%d+%d\n",
836 state->crtc_w, state->crtc_h,
837 state->crtc_x, state->crtc_y);
Rob Clark5e743732014-12-18 16:01:51 -0500838 return -ERANGE;
839 }
840
841 fb_width = state->fb->width << 16;
842 fb_height = state->fb->height << 16;
843
844 /* Make sure source coordinates are inside the fb. */
845 if (state->src_w > fb_width ||
846 state->src_x > fb_width - state->src_w ||
847 state->src_h > fb_height ||
848 state->src_y > fb_height - state->src_h) {
Daniel Vetter17a38d92015-02-22 12:24:16 +0100849 DRM_DEBUG_ATOMIC("Invalid source coordinates "
850 "%u.%06ux%u.%06u+%u.%06u+%u.%06u\n",
851 state->src_w >> 16, ((state->src_w & 0xffff) * 15625) >> 10,
852 state->src_h >> 16, ((state->src_h & 0xffff) * 15625) >> 10,
853 state->src_x >> 16, ((state->src_x & 0xffff) * 15625) >> 10,
854 state->src_y >> 16, ((state->src_y & 0xffff) * 15625) >> 10);
Rob Clark5e743732014-12-18 16:01:51 -0500855 return -ENOSPC;
856 }
857
Daniel Vetterf8aeb412015-08-26 21:49:42 +0200858 if (plane_switching_crtc(state->state, plane, state)) {
Ville Syrjälä9f4c97a2015-12-08 18:41:54 +0200859 DRM_DEBUG_ATOMIC("[PLANE:%d:%s] switching CRTC directly\n",
860 plane->base.id, plane->name);
Daniel Vetterf8aeb412015-08-26 21:49:42 +0200861 return -EINVAL;
862 }
863
Rob Clark5e743732014-12-18 16:01:51 -0500864 return 0;
865}
866
867/**
Daniel Vettercc4ceb42014-07-25 21:30:38 +0200868 * drm_atomic_get_connector_state - get connector state
869 * @state: global atomic state object
870 * @connector: connector to get state object for
871 *
872 * This function returns the connector state for the given connector,
873 * allocating it if needed. It will also grab the relevant connector lock to
874 * make sure that the state is consistent.
875 *
876 * Returns:
877 *
878 * Either the allocated state or the error code encoded into the pointer. When
879 * the error is EDEADLK then the w/w mutex code has detected a deadlock and the
880 * entire atomic sequence must be restarted. All other errors are fatal.
881 */
882struct drm_connector_state *
883drm_atomic_get_connector_state(struct drm_atomic_state *state,
884 struct drm_connector *connector)
885{
886 int ret, index;
887 struct drm_mode_config *config = &connector->dev->mode_config;
888 struct drm_connector_state *connector_state;
889
Maarten Lankhorst7f4eaa82016-05-03 11:12:31 +0200890 WARN_ON(!state->acquire_ctx);
891
Daniel Vetterc7eb76f2014-11-19 18:38:06 +0100892 ret = drm_modeset_lock(&config->connection_mutex, state->acquire_ctx);
893 if (ret)
894 return ERR_PTR(ret);
895
Daniel Vettercc4ceb42014-07-25 21:30:38 +0200896 index = drm_connector_index(connector);
897
Daniel Vetterf52b69f12014-11-19 18:38:08 +0100898 if (index >= state->num_connector) {
Maarten Lankhorst5fff80b2016-02-17 08:32:05 +0100899 struct drm_connector **c;
900 struct drm_connector_state **cs;
901 int alloc = max(index + 1, config->num_connector);
902
903 c = krealloc(state->connectors, alloc * sizeof(*state->connectors), GFP_KERNEL);
904 if (!c)
905 return ERR_PTR(-ENOMEM);
906
907 state->connectors = c;
908 memset(&state->connectors[state->num_connector], 0,
909 sizeof(*state->connectors) * (alloc - state->num_connector));
910
911 cs = krealloc(state->connector_states, alloc * sizeof(*state->connector_states), GFP_KERNEL);
912 if (!cs)
913 return ERR_PTR(-ENOMEM);
914
915 state->connector_states = cs;
916 memset(&state->connector_states[state->num_connector], 0,
917 sizeof(*state->connector_states) * (alloc - state->num_connector));
918 state->num_connector = alloc;
Daniel Vetterf52b69f12014-11-19 18:38:08 +0100919 }
920
Daniel Vettercc4ceb42014-07-25 21:30:38 +0200921 if (state->connector_states[index])
922 return state->connector_states[index];
923
Daniel Vettercc4ceb42014-07-25 21:30:38 +0200924 connector_state = connector->funcs->atomic_duplicate_state(connector);
925 if (!connector_state)
926 return ERR_PTR(-ENOMEM);
927
Dave Airlieb164d312016-04-27 11:10:09 +1000928 drm_connector_reference(connector);
Daniel Vettercc4ceb42014-07-25 21:30:38 +0200929 state->connector_states[index] = connector_state;
930 state->connectors[index] = connector;
931 connector_state->state = state;
932
Daniel Vetter17a38d92015-02-22 12:24:16 +0100933 DRM_DEBUG_ATOMIC("Added [CONNECTOR:%d] %p state to %p\n",
934 connector->base.id, connector_state, state);
Daniel Vettercc4ceb42014-07-25 21:30:38 +0200935
936 if (connector_state->crtc) {
937 struct drm_crtc_state *crtc_state;
938
939 crtc_state = drm_atomic_get_crtc_state(state,
940 connector_state->crtc);
941 if (IS_ERR(crtc_state))
942 return ERR_CAST(crtc_state);
943 }
944
945 return connector_state;
946}
947EXPORT_SYMBOL(drm_atomic_get_connector_state);
948
949/**
Rob Clark40ecc692014-12-18 16:01:46 -0500950 * drm_atomic_connector_set_property - set property on connector.
951 * @connector: the drm connector to set a property on
952 * @state: the state object to update with the new property value
953 * @property: the property to set
954 * @val: the new property value
955 *
956 * Use this instead of calling connector->atomic_set_property directly.
957 * This function handles generic/core properties and calls out to
958 * driver's ->atomic_set_property() for driver properties. To ensure
959 * consistent behavior you must call this function rather than the
960 * driver hook directly.
961 *
962 * RETURNS:
963 * Zero on success, error code on failure
964 */
965int drm_atomic_connector_set_property(struct drm_connector *connector,
966 struct drm_connector_state *state, struct drm_property *property,
967 uint64_t val)
968{
969 struct drm_device *dev = connector->dev;
970 struct drm_mode_config *config = &dev->mode_config;
971
Rob Clarkae16c592014-12-18 16:01:54 -0500972 if (property == config->prop_crtc_id) {
973 struct drm_crtc *crtc = drm_crtc_find(dev, val);
974 return drm_atomic_set_crtc_for_connector(state, crtc);
975 } else if (property == config->dpms_property) {
Rob Clark40ecc692014-12-18 16:01:46 -0500976 /* setting DPMS property requires special handling, which
977 * is done in legacy setprop path for us. Disallow (for
978 * now?) atomic writes to DPMS property:
979 */
980 return -EINVAL;
981 } else if (connector->funcs->atomic_set_property) {
982 return connector->funcs->atomic_set_property(connector,
983 state, property, val);
984 } else {
985 return -EINVAL;
986 }
987}
988EXPORT_SYMBOL(drm_atomic_connector_set_property);
989
Daniel Vetterc0714fc2015-12-04 09:45:57 +0100990/**
991 * drm_atomic_connector_get_property - get property value from connector state
992 * @connector: the drm connector to set a property on
993 * @state: the state object to get the property value from
994 * @property: the property to set
995 * @val: return location for the property value
996 *
Rob Clarkac9c9252014-12-18 16:01:47 -0500997 * This function handles generic/core properties and calls out to
998 * driver's ->atomic_get_property() for driver properties. To ensure
999 * consistent behavior you must call this function rather than the
1000 * driver hook directly.
Daniel Vetterc0714fc2015-12-04 09:45:57 +01001001 *
1002 * RETURNS:
1003 * Zero on success, error code on failure
Rob Clarkac9c9252014-12-18 16:01:47 -05001004 */
Daniel Vettera97df1c2014-12-18 22:49:02 +01001005static int
1006drm_atomic_connector_get_property(struct drm_connector *connector,
Rob Clarkac9c9252014-12-18 16:01:47 -05001007 const struct drm_connector_state *state,
1008 struct drm_property *property, uint64_t *val)
1009{
1010 struct drm_device *dev = connector->dev;
1011 struct drm_mode_config *config = &dev->mode_config;
1012
Rob Clarkae16c592014-12-18 16:01:54 -05001013 if (property == config->prop_crtc_id) {
1014 *val = (state->crtc) ? state->crtc->base.id : 0;
1015 } else if (property == config->dpms_property) {
Rob Clarkac9c9252014-12-18 16:01:47 -05001016 *val = connector->dpms;
1017 } else if (connector->funcs->atomic_get_property) {
1018 return connector->funcs->atomic_get_property(connector,
1019 state, property, val);
1020 } else {
1021 return -EINVAL;
1022 }
1023
1024 return 0;
1025}
Rob Clarkac9c9252014-12-18 16:01:47 -05001026
Rob Clark88a48e22014-12-18 16:01:50 -05001027int drm_atomic_get_property(struct drm_mode_object *obj,
1028 struct drm_property *property, uint64_t *val)
1029{
1030 struct drm_device *dev = property->dev;
1031 int ret;
1032
1033 switch (obj->type) {
1034 case DRM_MODE_OBJECT_CONNECTOR: {
1035 struct drm_connector *connector = obj_to_connector(obj);
1036 WARN_ON(!drm_modeset_is_locked(&dev->mode_config.connection_mutex));
1037 ret = drm_atomic_connector_get_property(connector,
1038 connector->state, property, val);
1039 break;
1040 }
1041 case DRM_MODE_OBJECT_CRTC: {
1042 struct drm_crtc *crtc = obj_to_crtc(obj);
1043 WARN_ON(!drm_modeset_is_locked(&crtc->mutex));
1044 ret = drm_atomic_crtc_get_property(crtc,
1045 crtc->state, property, val);
1046 break;
1047 }
1048 case DRM_MODE_OBJECT_PLANE: {
1049 struct drm_plane *plane = obj_to_plane(obj);
1050 WARN_ON(!drm_modeset_is_locked(&plane->mutex));
1051 ret = drm_atomic_plane_get_property(plane,
1052 plane->state, property, val);
1053 break;
1054 }
1055 default:
1056 ret = -EINVAL;
1057 break;
1058 }
1059
1060 return ret;
1061}
1062
1063/**
Daniel Vettercc4ceb42014-07-25 21:30:38 +02001064 * drm_atomic_set_crtc_for_plane - set crtc for plane
Daniel Vetter07cc0ef2014-11-27 15:49:39 +01001065 * @plane_state: the plane whose incoming state to update
Daniel Vettercc4ceb42014-07-25 21:30:38 +02001066 * @crtc: crtc to use for the plane
1067 *
1068 * Changing the assigned crtc for a plane requires us to grab the lock and state
1069 * for the new crtc, as needed. This function takes care of all these details
1070 * besides updating the pointer in the state object itself.
1071 *
1072 * Returns:
1073 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
1074 * then the w/w mutex code has detected a deadlock and the entire atomic
1075 * sequence must be restarted. All other errors are fatal.
1076 */
1077int
Daniel Vetter07cc0ef2014-11-27 15:49:39 +01001078drm_atomic_set_crtc_for_plane(struct drm_plane_state *plane_state,
1079 struct drm_crtc *crtc)
Daniel Vettercc4ceb42014-07-25 21:30:38 +02001080{
Daniel Vetter07cc0ef2014-11-27 15:49:39 +01001081 struct drm_plane *plane = plane_state->plane;
Daniel Vettercc4ceb42014-07-25 21:30:38 +02001082 struct drm_crtc_state *crtc_state;
1083
Rob Clark6ddd3882014-11-21 15:28:31 -05001084 if (plane_state->crtc) {
1085 crtc_state = drm_atomic_get_crtc_state(plane_state->state,
1086 plane_state->crtc);
1087 if (WARN_ON(IS_ERR(crtc_state)))
1088 return PTR_ERR(crtc_state);
1089
1090 crtc_state->plane_mask &= ~(1 << drm_plane_index(plane));
1091 }
1092
1093 plane_state->crtc = crtc;
1094
Daniel Vettercc4ceb42014-07-25 21:30:38 +02001095 if (crtc) {
1096 crtc_state = drm_atomic_get_crtc_state(plane_state->state,
1097 crtc);
1098 if (IS_ERR(crtc_state))
1099 return PTR_ERR(crtc_state);
Rob Clark6ddd3882014-11-21 15:28:31 -05001100 crtc_state->plane_mask |= (1 << drm_plane_index(plane));
Daniel Vettercc4ceb42014-07-25 21:30:38 +02001101 }
1102
Daniel Vettercc4ceb42014-07-25 21:30:38 +02001103 if (crtc)
Ville Syrjäläfa3ab4c2015-12-08 18:41:53 +02001104 DRM_DEBUG_ATOMIC("Link plane state %p to [CRTC:%d:%s]\n",
1105 plane_state, crtc->base.id, crtc->name);
Daniel Vettercc4ceb42014-07-25 21:30:38 +02001106 else
Daniel Vetter17a38d92015-02-22 12:24:16 +01001107 DRM_DEBUG_ATOMIC("Link plane state %p to [NOCRTC]\n",
1108 plane_state);
Daniel Vettercc4ceb42014-07-25 21:30:38 +02001109
1110 return 0;
1111}
1112EXPORT_SYMBOL(drm_atomic_set_crtc_for_plane);
1113
1114/**
John Hunter16d78bc2e2015-04-07 19:38:50 +08001115 * drm_atomic_set_fb_for_plane - set framebuffer for plane
Daniel Vetter321ebf02014-11-04 22:57:27 +01001116 * @plane_state: atomic state object for the plane
1117 * @fb: fb to use for the plane
1118 *
1119 * Changing the assigned framebuffer for a plane requires us to grab a reference
1120 * to the new fb and drop the reference to the old fb, if there is one. This
1121 * function takes care of all these details besides updating the pointer in the
1122 * state object itself.
1123 */
1124void
1125drm_atomic_set_fb_for_plane(struct drm_plane_state *plane_state,
1126 struct drm_framebuffer *fb)
1127{
1128 if (plane_state->fb)
1129 drm_framebuffer_unreference(plane_state->fb);
1130 if (fb)
1131 drm_framebuffer_reference(fb);
1132 plane_state->fb = fb;
1133
1134 if (fb)
Daniel Vetter17a38d92015-02-22 12:24:16 +01001135 DRM_DEBUG_ATOMIC("Set [FB:%d] for plane state %p\n",
1136 fb->base.id, plane_state);
Daniel Vetter321ebf02014-11-04 22:57:27 +01001137 else
Daniel Vetter17a38d92015-02-22 12:24:16 +01001138 DRM_DEBUG_ATOMIC("Set [NOFB] for plane state %p\n",
1139 plane_state);
Daniel Vetter321ebf02014-11-04 22:57:27 +01001140}
1141EXPORT_SYMBOL(drm_atomic_set_fb_for_plane);
1142
1143/**
Daniel Vettercc4ceb42014-07-25 21:30:38 +02001144 * drm_atomic_set_crtc_for_connector - set crtc for connector
1145 * @conn_state: atomic state object for the connector
1146 * @crtc: crtc to use for the connector
1147 *
1148 * Changing the assigned crtc for a connector requires us to grab the lock and
1149 * state for the new crtc, as needed. This function takes care of all these
1150 * details besides updating the pointer in the state object itself.
1151 *
1152 * Returns:
1153 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
1154 * then the w/w mutex code has detected a deadlock and the entire atomic
1155 * sequence must be restarted. All other errors are fatal.
1156 */
1157int
1158drm_atomic_set_crtc_for_connector(struct drm_connector_state *conn_state,
1159 struct drm_crtc *crtc)
1160{
1161 struct drm_crtc_state *crtc_state;
1162
Chris Wilsone2d800a2016-05-06 12:47:45 +01001163 if (conn_state->crtc == crtc)
1164 return 0;
1165
1166 if (conn_state->crtc) {
Maarten Lankhorst4cd9fa52016-01-04 12:53:18 +01001167 crtc_state = drm_atomic_get_existing_crtc_state(conn_state->state,
1168 conn_state->crtc);
1169
1170 crtc_state->connector_mask &=
1171 ~(1 << drm_connector_index(conn_state->connector));
Chris Wilsone2d800a2016-05-06 12:47:45 +01001172
1173 drm_connector_unreference(conn_state->connector);
1174 conn_state->crtc = NULL;
Maarten Lankhorst4cd9fa52016-01-04 12:53:18 +01001175 }
1176
Daniel Vettercc4ceb42014-07-25 21:30:38 +02001177 if (crtc) {
1178 crtc_state = drm_atomic_get_crtc_state(conn_state->state, crtc);
1179 if (IS_ERR(crtc_state))
1180 return PTR_ERR(crtc_state);
Maarten Lankhorst4cd9fa52016-01-04 12:53:18 +01001181
1182 crtc_state->connector_mask |=
1183 1 << drm_connector_index(conn_state->connector);
Daniel Vettercc4ceb42014-07-25 21:30:38 +02001184
Chris Wilsone2d800a2016-05-06 12:47:45 +01001185 drm_connector_reference(conn_state->connector);
1186 conn_state->crtc = crtc;
Daniel Vettercc4ceb42014-07-25 21:30:38 +02001187
Ville Syrjäläfa3ab4c2015-12-08 18:41:53 +02001188 DRM_DEBUG_ATOMIC("Link connector state %p to [CRTC:%d:%s]\n",
1189 conn_state, crtc->base.id, crtc->name);
Chris Wilsone2d800a2016-05-06 12:47:45 +01001190 } else {
Daniel Vetter17a38d92015-02-22 12:24:16 +01001191 DRM_DEBUG_ATOMIC("Link connector state %p to [NOCRTC]\n",
1192 conn_state);
Chris Wilsone2d800a2016-05-06 12:47:45 +01001193 }
Daniel Vettercc4ceb42014-07-25 21:30:38 +02001194
1195 return 0;
1196}
1197EXPORT_SYMBOL(drm_atomic_set_crtc_for_connector);
1198
1199/**
1200 * drm_atomic_add_affected_connectors - add connectors for crtc
1201 * @state: atomic state
1202 * @crtc: DRM crtc
1203 *
1204 * This function walks the current configuration and adds all connectors
1205 * currently using @crtc to the atomic configuration @state. Note that this
1206 * function must acquire the connection mutex. This can potentially cause
1207 * unneeded seralization if the update is just for the planes on one crtc. Hence
1208 * drivers and helpers should only call this when really needed (e.g. when a
1209 * full modeset needs to happen due to some change).
1210 *
1211 * Returns:
1212 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
1213 * then the w/w mutex code has detected a deadlock and the entire atomic
1214 * sequence must be restarted. All other errors are fatal.
1215 */
1216int
1217drm_atomic_add_affected_connectors(struct drm_atomic_state *state,
1218 struct drm_crtc *crtc)
1219{
1220 struct drm_mode_config *config = &state->dev->mode_config;
1221 struct drm_connector *connector;
1222 struct drm_connector_state *conn_state;
1223 int ret;
1224
1225 ret = drm_modeset_lock(&config->connection_mutex, state->acquire_ctx);
1226 if (ret)
1227 return ret;
1228
Ville Syrjäläfa3ab4c2015-12-08 18:41:53 +02001229 DRM_DEBUG_ATOMIC("Adding all current connectors for [CRTC:%d:%s] to %p\n",
1230 crtc->base.id, crtc->name, state);
Daniel Vettercc4ceb42014-07-25 21:30:38 +02001231
1232 /*
1233 * Changed connectors are already in @state, so only need to look at the
1234 * current configuration.
1235 */
Daniel Vetter9a9f5ce2015-07-09 23:44:34 +02001236 drm_for_each_connector(connector, state->dev) {
Daniel Vettercc4ceb42014-07-25 21:30:38 +02001237 if (connector->state->crtc != crtc)
1238 continue;
1239
1240 conn_state = drm_atomic_get_connector_state(state, connector);
1241 if (IS_ERR(conn_state))
1242 return PTR_ERR(conn_state);
1243 }
1244
1245 return 0;
1246}
1247EXPORT_SYMBOL(drm_atomic_add_affected_connectors);
1248
1249/**
Maarten Lankhorste01e9f72015-05-19 16:41:02 +02001250 * drm_atomic_add_affected_planes - add planes for crtc
1251 * @state: atomic state
1252 * @crtc: DRM crtc
1253 *
1254 * This function walks the current configuration and adds all planes
1255 * currently used by @crtc to the atomic configuration @state. This is useful
1256 * when an atomic commit also needs to check all currently enabled plane on
1257 * @crtc, e.g. when changing the mode. It's also useful when re-enabling a CRTC
1258 * to avoid special code to force-enable all planes.
1259 *
1260 * Since acquiring a plane state will always also acquire the w/w mutex of the
1261 * current CRTC for that plane (if there is any) adding all the plane states for
1262 * a CRTC will not reduce parallism of atomic updates.
1263 *
1264 * Returns:
1265 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
1266 * then the w/w mutex code has detected a deadlock and the entire atomic
1267 * sequence must be restarted. All other errors are fatal.
1268 */
1269int
1270drm_atomic_add_affected_planes(struct drm_atomic_state *state,
1271 struct drm_crtc *crtc)
1272{
1273 struct drm_plane *plane;
1274
1275 WARN_ON(!drm_atomic_get_existing_crtc_state(state, crtc));
1276
1277 drm_for_each_plane_mask(plane, state->dev, crtc->state->plane_mask) {
1278 struct drm_plane_state *plane_state =
1279 drm_atomic_get_plane_state(state, plane);
1280
1281 if (IS_ERR(plane_state))
1282 return PTR_ERR(plane_state);
1283 }
1284 return 0;
1285}
1286EXPORT_SYMBOL(drm_atomic_add_affected_planes);
1287
1288/**
Daniel Vettercc4ceb42014-07-25 21:30:38 +02001289 * drm_atomic_legacy_backoff - locking backoff for legacy ioctls
1290 * @state: atomic state
1291 *
1292 * This function should be used by legacy entry points which don't understand
1293 * -EDEADLK semantics. For simplicity this one will grab all modeset locks after
John Hunter16d78bc2e2015-04-07 19:38:50 +08001294 * the slowpath completed.
Daniel Vettercc4ceb42014-07-25 21:30:38 +02001295 */
1296void drm_atomic_legacy_backoff(struct drm_atomic_state *state)
1297{
1298 int ret;
1299
1300retry:
1301 drm_modeset_backoff(state->acquire_ctx);
1302
Thierry Reding06eaae42015-12-02 17:50:03 +01001303 ret = drm_modeset_lock_all_ctx(state->dev, state->acquire_ctx);
Daniel Vettercc4ceb42014-07-25 21:30:38 +02001304 if (ret)
1305 goto retry;
1306}
1307EXPORT_SYMBOL(drm_atomic_legacy_backoff);
1308
1309/**
1310 * drm_atomic_check_only - check whether a given config would work
1311 * @state: atomic configuration to check
1312 *
1313 * Note that this function can return -EDEADLK if the driver needed to acquire
1314 * more locks but encountered a deadlock. The caller must then do the usual w/w
1315 * backoff dance and restart. All other errors are fatal.
1316 *
1317 * Returns:
1318 * 0 on success, negative error code on failure.
1319 */
1320int drm_atomic_check_only(struct drm_atomic_state *state)
1321{
Rob Clark5e743732014-12-18 16:01:51 -05001322 struct drm_device *dev = state->dev;
1323 struct drm_mode_config *config = &dev->mode_config;
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +03001324 struct drm_plane *plane;
1325 struct drm_plane_state *plane_state;
1326 struct drm_crtc *crtc;
1327 struct drm_crtc_state *crtc_state;
Rob Clark5e743732014-12-18 16:01:51 -05001328 int i, ret = 0;
Daniel Vettercc4ceb42014-07-25 21:30:38 +02001329
Daniel Vetter17a38d92015-02-22 12:24:16 +01001330 DRM_DEBUG_ATOMIC("checking %p\n", state);
Daniel Vettercc4ceb42014-07-25 21:30:38 +02001331
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +03001332 for_each_plane_in_state(state, plane, plane_state, i) {
1333 ret = drm_atomic_plane_check(plane, plane_state);
Rob Clark5e743732014-12-18 16:01:51 -05001334 if (ret) {
Ville Syrjälä9f4c97a2015-12-08 18:41:54 +02001335 DRM_DEBUG_ATOMIC("[PLANE:%d:%s] atomic core check failed\n",
1336 plane->base.id, plane->name);
Rob Clark5e743732014-12-18 16:01:51 -05001337 return ret;
1338 }
1339 }
1340
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +03001341 for_each_crtc_in_state(state, crtc, crtc_state, i) {
1342 ret = drm_atomic_crtc_check(crtc, crtc_state);
Rob Clark5e743732014-12-18 16:01:51 -05001343 if (ret) {
Ville Syrjäläfa3ab4c2015-12-08 18:41:53 +02001344 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] atomic core check failed\n",
1345 crtc->base.id, crtc->name);
Rob Clark5e743732014-12-18 16:01:51 -05001346 return ret;
1347 }
1348 }
1349
Daniel Vettercc4ceb42014-07-25 21:30:38 +02001350 if (config->funcs->atomic_check)
Rob Clark5e743732014-12-18 16:01:51 -05001351 ret = config->funcs->atomic_check(state->dev, state);
1352
Rob Clarkd34f20d2014-12-18 16:01:56 -05001353 if (!state->allow_modeset) {
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +03001354 for_each_crtc_in_state(state, crtc, crtc_state, i) {
Daniel Vetter2465ff62015-06-18 09:58:55 +02001355 if (drm_atomic_crtc_needs_modeset(crtc_state)) {
Ville Syrjäläfa3ab4c2015-12-08 18:41:53 +02001356 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] requires full modeset\n",
1357 crtc->base.id, crtc->name);
Rob Clarkd34f20d2014-12-18 16:01:56 -05001358 return -EINVAL;
1359 }
1360 }
1361 }
1362
Rob Clark5e743732014-12-18 16:01:51 -05001363 return ret;
Daniel Vettercc4ceb42014-07-25 21:30:38 +02001364}
1365EXPORT_SYMBOL(drm_atomic_check_only);
1366
1367/**
1368 * drm_atomic_commit - commit configuration atomically
1369 * @state: atomic configuration to check
1370 *
1371 * Note that this function can return -EDEADLK if the driver needed to acquire
1372 * more locks but encountered a deadlock. The caller must then do the usual w/w
1373 * backoff dance and restart. All other errors are fatal.
1374 *
1375 * Also note that on successful execution ownership of @state is transferred
1376 * from the caller of this function to the function itself. The caller must not
1377 * free or in any other way access @state. If the function fails then the caller
1378 * must clean up @state itself.
1379 *
1380 * Returns:
1381 * 0 on success, negative error code on failure.
1382 */
1383int drm_atomic_commit(struct drm_atomic_state *state)
1384{
1385 struct drm_mode_config *config = &state->dev->mode_config;
1386 int ret;
1387
1388 ret = drm_atomic_check_only(state);
1389 if (ret)
1390 return ret;
1391
Daniel Vetter17a38d92015-02-22 12:24:16 +01001392 DRM_DEBUG_ATOMIC("commiting %p\n", state);
Daniel Vettercc4ceb42014-07-25 21:30:38 +02001393
1394 return config->funcs->atomic_commit(state->dev, state, false);
1395}
1396EXPORT_SYMBOL(drm_atomic_commit);
1397
1398/**
Maarten Lankhorstb837ba02016-04-26 16:11:35 +02001399 * drm_atomic_nonblocking_commit - atomic&nonblocking configuration commit
Daniel Vettercc4ceb42014-07-25 21:30:38 +02001400 * @state: atomic configuration to check
1401 *
1402 * Note that this function can return -EDEADLK if the driver needed to acquire
1403 * more locks but encountered a deadlock. The caller must then do the usual w/w
1404 * backoff dance and restart. All other errors are fatal.
1405 *
1406 * Also note that on successful execution ownership of @state is transferred
1407 * from the caller of this function to the function itself. The caller must not
1408 * free or in any other way access @state. If the function fails then the caller
1409 * must clean up @state itself.
1410 *
1411 * Returns:
1412 * 0 on success, negative error code on failure.
1413 */
Maarten Lankhorstb837ba02016-04-26 16:11:35 +02001414int drm_atomic_nonblocking_commit(struct drm_atomic_state *state)
Daniel Vettercc4ceb42014-07-25 21:30:38 +02001415{
1416 struct drm_mode_config *config = &state->dev->mode_config;
1417 int ret;
1418
1419 ret = drm_atomic_check_only(state);
1420 if (ret)
1421 return ret;
1422
Maarten Lankhorstb837ba02016-04-26 16:11:35 +02001423 DRM_DEBUG_ATOMIC("commiting %p nonblocking\n", state);
Daniel Vettercc4ceb42014-07-25 21:30:38 +02001424
1425 return config->funcs->atomic_commit(state->dev, state, true);
1426}
Maarten Lankhorstb837ba02016-04-26 16:11:35 +02001427EXPORT_SYMBOL(drm_atomic_nonblocking_commit);
Rob Clarkd34f20d2014-12-18 16:01:56 -05001428
1429/*
1430 * The big monstor ioctl
1431 */
1432
1433static struct drm_pending_vblank_event *create_vblank_event(
1434 struct drm_device *dev, struct drm_file *file_priv, uint64_t user_data)
1435{
1436 struct drm_pending_vblank_event *e = NULL;
Daniel Vetter2dd500f2016-01-11 22:40:56 +01001437 int ret;
Rob Clarkd34f20d2014-12-18 16:01:56 -05001438
1439 e = kzalloc(sizeof *e, GFP_KERNEL);
Daniel Vetter2dd500f2016-01-11 22:40:56 +01001440 if (!e)
1441 return NULL;
Rob Clarkd34f20d2014-12-18 16:01:56 -05001442
1443 e->event.base.type = DRM_EVENT_FLIP_COMPLETE;
Daniel Vetter2dd500f2016-01-11 22:40:56 +01001444 e->event.base.length = sizeof(e->event);
Rob Clarkd34f20d2014-12-18 16:01:56 -05001445 e->event.user_data = user_data;
Rob Clarkd34f20d2014-12-18 16:01:56 -05001446
Daniel Vetter2dd500f2016-01-11 22:40:56 +01001447 ret = drm_event_reserve_init(dev, file_priv, &e->base, &e->event.base);
1448 if (ret) {
1449 kfree(e);
1450 return NULL;
1451 }
1452
Rob Clarkd34f20d2014-12-18 16:01:56 -05001453 return e;
1454}
1455
Rob Clarkd34f20d2014-12-18 16:01:56 -05001456static int atomic_set_prop(struct drm_atomic_state *state,
1457 struct drm_mode_object *obj, struct drm_property *prop,
1458 uint64_t prop_value)
1459{
1460 struct drm_mode_object *ref;
1461 int ret;
1462
1463 if (!drm_property_change_valid_get(prop, prop_value, &ref))
1464 return -EINVAL;
1465
1466 switch (obj->type) {
1467 case DRM_MODE_OBJECT_CONNECTOR: {
1468 struct drm_connector *connector = obj_to_connector(obj);
1469 struct drm_connector_state *connector_state;
1470
1471 connector_state = drm_atomic_get_connector_state(state, connector);
1472 if (IS_ERR(connector_state)) {
1473 ret = PTR_ERR(connector_state);
1474 break;
1475 }
1476
1477 ret = drm_atomic_connector_set_property(connector,
1478 connector_state, prop, prop_value);
1479 break;
1480 }
1481 case DRM_MODE_OBJECT_CRTC: {
1482 struct drm_crtc *crtc = obj_to_crtc(obj);
1483 struct drm_crtc_state *crtc_state;
1484
1485 crtc_state = drm_atomic_get_crtc_state(state, crtc);
1486 if (IS_ERR(crtc_state)) {
1487 ret = PTR_ERR(crtc_state);
1488 break;
1489 }
1490
1491 ret = drm_atomic_crtc_set_property(crtc,
1492 crtc_state, prop, prop_value);
1493 break;
1494 }
1495 case DRM_MODE_OBJECT_PLANE: {
1496 struct drm_plane *plane = obj_to_plane(obj);
1497 struct drm_plane_state *plane_state;
1498
1499 plane_state = drm_atomic_get_plane_state(state, plane);
1500 if (IS_ERR(plane_state)) {
1501 ret = PTR_ERR(plane_state);
1502 break;
1503 }
1504
1505 ret = drm_atomic_plane_set_property(plane,
1506 plane_state, prop, prop_value);
1507 break;
1508 }
1509 default:
1510 ret = -EINVAL;
1511 break;
1512 }
1513
1514 drm_property_change_valid_put(prop, ref);
1515 return ret;
1516}
1517
Maarten Lankhorst0f45c262015-11-11 11:29:09 +01001518/**
Maarten Lankhorst9744bf42015-11-24 10:34:34 +01001519 * drm_atomic_clean_old_fb -- Unset old_fb pointers and set plane->fb pointers.
Maarten Lankhorst0f45c262015-11-11 11:29:09 +01001520 *
1521 * @dev: drm device to check.
1522 * @plane_mask: plane mask for planes that were updated.
1523 * @ret: return value, can be -EDEADLK for a retry.
1524 *
1525 * Before doing an update plane->old_fb is set to plane->fb,
1526 * but before dropping the locks old_fb needs to be set to NULL
1527 * and plane->fb updated. This is a common operation for each
1528 * atomic update, so this call is split off as a helper.
1529 */
1530void drm_atomic_clean_old_fb(struct drm_device *dev,
1531 unsigned plane_mask,
1532 int ret)
1533{
1534 struct drm_plane *plane;
1535
1536 /* if succeeded, fixup legacy plane crtc/fb ptrs before dropping
1537 * locks (ie. while it is still safe to deref plane->state). We
1538 * need to do this here because the driver entry points cannot
1539 * distinguish between legacy and atomic ioctls.
1540 */
1541 drm_for_each_plane_mask(plane, dev, plane_mask) {
1542 if (ret == 0) {
1543 struct drm_framebuffer *new_fb = plane->state->fb;
1544 if (new_fb)
1545 drm_framebuffer_reference(new_fb);
1546 plane->fb = new_fb;
1547 plane->crtc = plane->state->crtc;
1548
1549 if (plane->old_fb)
1550 drm_framebuffer_unreference(plane->old_fb);
1551 }
1552 plane->old_fb = NULL;
1553 }
1554}
1555EXPORT_SYMBOL(drm_atomic_clean_old_fb);
1556
Rob Clarkd34f20d2014-12-18 16:01:56 -05001557int drm_mode_atomic_ioctl(struct drm_device *dev,
1558 void *data, struct drm_file *file_priv)
1559{
1560 struct drm_mode_atomic *arg = data;
1561 uint32_t __user *objs_ptr = (uint32_t __user *)(unsigned long)(arg->objs_ptr);
1562 uint32_t __user *count_props_ptr = (uint32_t __user *)(unsigned long)(arg->count_props_ptr);
1563 uint32_t __user *props_ptr = (uint32_t __user *)(unsigned long)(arg->props_ptr);
1564 uint64_t __user *prop_values_ptr = (uint64_t __user *)(unsigned long)(arg->prop_values_ptr);
1565 unsigned int copied_objs, copied_props;
1566 struct drm_atomic_state *state;
1567 struct drm_modeset_acquire_ctx ctx;
1568 struct drm_plane *plane;
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +03001569 struct drm_crtc *crtc;
1570 struct drm_crtc_state *crtc_state;
Maarten Lankhorst45723722015-11-11 11:29:08 +01001571 unsigned plane_mask;
Rob Clarkd34f20d2014-12-18 16:01:56 -05001572 int ret = 0;
1573 unsigned int i, j;
1574
1575 /* disallow for drivers not supporting atomic: */
1576 if (!drm_core_check_feature(dev, DRIVER_ATOMIC))
1577 return -EINVAL;
1578
1579 /* disallow for userspace that has not enabled atomic cap (even
1580 * though this may be a bit overkill, since legacy userspace
1581 * wouldn't know how to call this ioctl)
1582 */
1583 if (!file_priv->atomic)
1584 return -EINVAL;
1585
1586 if (arg->flags & ~DRM_MODE_ATOMIC_FLAGS)
1587 return -EINVAL;
1588
1589 if (arg->reserved)
1590 return -EINVAL;
1591
1592 if ((arg->flags & DRM_MODE_PAGE_FLIP_ASYNC) &&
1593 !dev->mode_config.async_page_flip)
1594 return -EINVAL;
1595
1596 /* can't test and expect an event at the same time. */
1597 if ((arg->flags & DRM_MODE_ATOMIC_TEST_ONLY) &&
1598 (arg->flags & DRM_MODE_PAGE_FLIP_EVENT))
1599 return -EINVAL;
1600
1601 drm_modeset_acquire_init(&ctx, 0);
1602
1603 state = drm_atomic_state_alloc(dev);
1604 if (!state)
1605 return -ENOMEM;
1606
1607 state->acquire_ctx = &ctx;
1608 state->allow_modeset = !!(arg->flags & DRM_MODE_ATOMIC_ALLOW_MODESET);
1609
1610retry:
Maarten Lankhorst45723722015-11-11 11:29:08 +01001611 plane_mask = 0;
Rob Clarkd34f20d2014-12-18 16:01:56 -05001612 copied_objs = 0;
1613 copied_props = 0;
1614
1615 for (i = 0; i < arg->count_objs; i++) {
1616 uint32_t obj_id, count_props;
1617 struct drm_mode_object *obj;
1618
1619 if (get_user(obj_id, objs_ptr + copied_objs)) {
1620 ret = -EFAULT;
Maarten Lankhorstec9f9322015-06-24 08:59:25 +02001621 goto out;
Rob Clarkd34f20d2014-12-18 16:01:56 -05001622 }
1623
1624 obj = drm_mode_object_find(dev, obj_id, DRM_MODE_OBJECT_ANY);
Dave Airlieb164d312016-04-27 11:10:09 +10001625 if (!obj) {
1626 ret = -ENOENT;
1627 goto out;
1628 }
1629
1630 if (!obj->properties) {
1631 drm_mode_object_unreference(obj);
Rob Clarkd34f20d2014-12-18 16:01:56 -05001632 ret = -ENOENT;
Maarten Lankhorstec9f9322015-06-24 08:59:25 +02001633 goto out;
Rob Clarkd34f20d2014-12-18 16:01:56 -05001634 }
1635
Rob Clarkd34f20d2014-12-18 16:01:56 -05001636 if (get_user(count_props, count_props_ptr + copied_objs)) {
Dave Airlieb164d312016-04-27 11:10:09 +10001637 drm_mode_object_unreference(obj);
Rob Clarkd34f20d2014-12-18 16:01:56 -05001638 ret = -EFAULT;
Maarten Lankhorstec9f9322015-06-24 08:59:25 +02001639 goto out;
Rob Clarkd34f20d2014-12-18 16:01:56 -05001640 }
1641
1642 copied_objs++;
1643
1644 for (j = 0; j < count_props; j++) {
1645 uint32_t prop_id;
1646 uint64_t prop_value;
1647 struct drm_property *prop;
1648
1649 if (get_user(prop_id, props_ptr + copied_props)) {
Dave Airlieb164d312016-04-27 11:10:09 +10001650 drm_mode_object_unreference(obj);
Rob Clarkd34f20d2014-12-18 16:01:56 -05001651 ret = -EFAULT;
Maarten Lankhorstec9f9322015-06-24 08:59:25 +02001652 goto out;
Rob Clarkd34f20d2014-12-18 16:01:56 -05001653 }
1654
1655 prop = drm_property_find(dev, prop_id);
1656 if (!prop) {
Dave Airlieb164d312016-04-27 11:10:09 +10001657 drm_mode_object_unreference(obj);
Rob Clarkd34f20d2014-12-18 16:01:56 -05001658 ret = -ENOENT;
Maarten Lankhorstec9f9322015-06-24 08:59:25 +02001659 goto out;
Rob Clarkd34f20d2014-12-18 16:01:56 -05001660 }
1661
Guenter Roeck42c58142015-01-12 21:12:17 -08001662 if (copy_from_user(&prop_value,
1663 prop_values_ptr + copied_props,
1664 sizeof(prop_value))) {
Dave Airlieb164d312016-04-27 11:10:09 +10001665 drm_mode_object_unreference(obj);
Rob Clarkd34f20d2014-12-18 16:01:56 -05001666 ret = -EFAULT;
Maarten Lankhorstec9f9322015-06-24 08:59:25 +02001667 goto out;
Rob Clarkd34f20d2014-12-18 16:01:56 -05001668 }
1669
1670 ret = atomic_set_prop(state, obj, prop, prop_value);
Dave Airlieb164d312016-04-27 11:10:09 +10001671 if (ret) {
1672 drm_mode_object_unreference(obj);
Maarten Lankhorstec9f9322015-06-24 08:59:25 +02001673 goto out;
Dave Airlieb164d312016-04-27 11:10:09 +10001674 }
Rob Clarkd34f20d2014-12-18 16:01:56 -05001675
1676 copied_props++;
1677 }
Maarten Lankhorsta9cc54e2015-06-24 08:59:24 +02001678
Maarten Lankhorstc4749c92015-08-31 12:25:04 +02001679 if (obj->type == DRM_MODE_OBJECT_PLANE && count_props &&
1680 !(arg->flags & DRM_MODE_ATOMIC_TEST_ONLY)) {
Maarten Lankhorsta9cc54e2015-06-24 08:59:24 +02001681 plane = obj_to_plane(obj);
1682 plane_mask |= (1 << drm_plane_index(plane));
1683 plane->old_fb = plane->fb;
1684 }
Dave Airlieb164d312016-04-27 11:10:09 +10001685 drm_mode_object_unreference(obj);
Rob Clarkd34f20d2014-12-18 16:01:56 -05001686 }
1687
1688 if (arg->flags & DRM_MODE_PAGE_FLIP_EVENT) {
Ander Conselvan de Oliveiradf63b992015-04-10 14:58:39 +03001689 for_each_crtc_in_state(state, crtc, crtc_state, i) {
Rob Clarkd34f20d2014-12-18 16:01:56 -05001690 struct drm_pending_vblank_event *e;
1691
Rob Clarkd34f20d2014-12-18 16:01:56 -05001692 e = create_vblank_event(dev, file_priv, arg->user_data);
1693 if (!e) {
1694 ret = -ENOMEM;
Maarten Lankhorstec9f9322015-06-24 08:59:25 +02001695 goto out;
Rob Clarkd34f20d2014-12-18 16:01:56 -05001696 }
1697
1698 crtc_state->event = e;
1699 }
1700 }
1701
1702 if (arg->flags & DRM_MODE_ATOMIC_TEST_ONLY) {
Maarten Lankhorstc4749c92015-08-31 12:25:04 +02001703 /*
1704 * Unlike commit, check_only does not clean up state.
1705 * Below we call drm_atomic_state_free for it.
1706 */
Rob Clarkd34f20d2014-12-18 16:01:56 -05001707 ret = drm_atomic_check_only(state);
Rob Clarkd34f20d2014-12-18 16:01:56 -05001708 } else if (arg->flags & DRM_MODE_ATOMIC_NONBLOCK) {
Maarten Lankhorstb837ba02016-04-26 16:11:35 +02001709 ret = drm_atomic_nonblocking_commit(state);
Rob Clarkd34f20d2014-12-18 16:01:56 -05001710 } else {
1711 ret = drm_atomic_commit(state);
1712 }
1713
Maarten Lankhorstec9f9322015-06-24 08:59:25 +02001714out:
Maarten Lankhorst0f45c262015-11-11 11:29:09 +01001715 drm_atomic_clean_old_fb(dev, plane_mask, ret);
Maarten Lankhorstec9f9322015-06-24 08:59:25 +02001716
Maarten Lankhorstc4749c92015-08-31 12:25:04 +02001717 if (ret && arg->flags & DRM_MODE_PAGE_FLIP_EVENT) {
1718 /*
1719 * TEST_ONLY and PAGE_FLIP_EVENT are mutually exclusive,
1720 * if they weren't, this code should be called on success
1721 * for TEST_ONLY too.
1722 */
1723
1724 for_each_crtc_in_state(state, crtc, crtc_state, i) {
1725 if (!crtc_state->event)
1726 continue;
1727
Daniel Vetter2dd500f2016-01-11 22:40:56 +01001728 drm_event_cancel_free(dev, &crtc_state->event->base);
Maarten Lankhorstc4749c92015-08-31 12:25:04 +02001729 }
1730 }
1731
Maarten Lankhorstec9f9322015-06-24 08:59:25 +02001732 if (ret == -EDEADLK) {
1733 drm_atomic_state_clear(state);
1734 drm_modeset_backoff(&ctx);
1735 goto retry;
1736 }
1737
Maarten Lankhorstc4749c92015-08-31 12:25:04 +02001738 if (ret || arg->flags & DRM_MODE_ATOMIC_TEST_ONLY)
Maarten Lankhorstec9f9322015-06-24 08:59:25 +02001739 drm_atomic_state_free(state);
Rob Clarkd34f20d2014-12-18 16:01:56 -05001740
1741 drm_modeset_drop_locks(&ctx);
1742 drm_modeset_acquire_fini(&ctx);
1743
1744 return ret;
Rob Clarkd34f20d2014-12-18 16:01:56 -05001745}