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