Rev 6084 | Go to most recent revision | Details | 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 |
||
31 | #include |
||
32 | |||
33 | static void kfree_state(struct drm_atomic_state *state) |
||
34 | { |
||
35 | kfree(state->connectors); |
||
36 | kfree(state->connector_states); |
||
37 | kfree(state->crtcs); |
||
38 | kfree(state->crtc_states); |
||
39 | kfree(state->planes); |
||
40 | kfree(state->plane_states); |
||
41 | kfree(state); |
||
42 | } |
||
43 | |||
44 | /** |
||
45 | * drm_atomic_state_alloc - allocate atomic state |
||
46 | * @dev: DRM device |
||
47 | * |
||
48 | * This allocates an empty atomic state to track updates. |
||
49 | */ |
||
50 | struct drm_atomic_state * |
||
51 | drm_atomic_state_alloc(struct drm_device *dev) |
||
52 | { |
||
53 | struct drm_atomic_state *state; |
||
54 | |||
55 | state = kzalloc(sizeof(*state), GFP_KERNEL); |
||
56 | if (!state) |
||
57 | return NULL; |
||
58 | |||
59 | state->num_connector = ACCESS_ONCE(dev->mode_config.num_connector); |
||
60 | |||
61 | state->crtcs = kcalloc(dev->mode_config.num_crtc, |
||
62 | sizeof(*state->crtcs), GFP_KERNEL); |
||
63 | if (!state->crtcs) |
||
64 | goto fail; |
||
65 | state->crtc_states = kcalloc(dev->mode_config.num_crtc, |
||
66 | sizeof(*state->crtc_states), GFP_KERNEL); |
||
67 | if (!state->crtc_states) |
||
68 | goto fail; |
||
69 | state->planes = kcalloc(dev->mode_config.num_total_plane, |
||
70 | sizeof(*state->planes), GFP_KERNEL); |
||
71 | if (!state->planes) |
||
72 | goto fail; |
||
73 | state->plane_states = kcalloc(dev->mode_config.num_total_plane, |
||
74 | sizeof(*state->plane_states), GFP_KERNEL); |
||
75 | if (!state->plane_states) |
||
76 | goto fail; |
||
77 | state->connectors = kcalloc(state->num_connector, |
||
78 | sizeof(*state->connectors), |
||
79 | GFP_KERNEL); |
||
80 | if (!state->connectors) |
||
81 | goto fail; |
||
82 | state->connector_states = kcalloc(state->num_connector, |
||
83 | sizeof(*state->connector_states), |
||
84 | GFP_KERNEL); |
||
85 | if (!state->connector_states) |
||
86 | goto fail; |
||
87 | |||
88 | state->dev = dev; |
||
89 | |||
90 | DRM_DEBUG_KMS("Allocate atomic state %p\n", state); |
||
91 | |||
92 | return state; |
||
93 | fail: |
||
94 | kfree_state(state); |
||
95 | |||
96 | return NULL; |
||
97 | } |
||
98 | EXPORT_SYMBOL(drm_atomic_state_alloc); |
||
99 | |||
100 | /** |
||
101 | * drm_atomic_state_clear - clear state object |
||
102 | * @state: atomic state |
||
103 | * |
||
104 | * When the w/w mutex algorithm detects a deadlock we need to back off and drop |
||
105 | * all locks. So someone else could sneak in and change the current modeset |
||
106 | * configuration. Which means that all the state assembled in @state is no |
||
107 | * longer an atomic update to the current state, but to some arbitrary earlier |
||
108 | * state. Which could break assumptions the driver's ->atomic_check likely |
||
109 | * relies on. |
||
110 | * |
||
111 | * Hence we must clear all cached state and completely start over, using this |
||
112 | * function. |
||
113 | */ |
||
114 | void drm_atomic_state_clear(struct drm_atomic_state *state) |
||
115 | { |
||
116 | struct drm_device *dev = state->dev; |
||
117 | struct drm_mode_config *config = &dev->mode_config; |
||
118 | int i; |
||
119 | |||
120 | DRM_DEBUG_KMS("Clearing atomic state %p\n", state); |
||
121 | |||
122 | for (i = 0; i < state->num_connector; i++) { |
||
123 | struct drm_connector *connector = state->connectors[i]; |
||
124 | |||
125 | if (!connector) |
||
126 | continue; |
||
127 | |||
128 | WARN_ON(!drm_modeset_is_locked(&config->connection_mutex)); |
||
129 | |||
130 | connector->funcs->atomic_destroy_state(connector, |
||
131 | state->connector_states[i]); |
||
132 | } |
||
133 | |||
134 | for (i = 0; i < config->num_crtc; i++) { |
||
135 | struct drm_crtc *crtc = state->crtcs[i]; |
||
136 | |||
137 | if (!crtc) |
||
138 | continue; |
||
139 | |||
140 | crtc->funcs->atomic_destroy_state(crtc, |
||
141 | state->crtc_states[i]); |
||
142 | } |
||
143 | |||
144 | for (i = 0; i < config->num_total_plane; i++) { |
||
145 | struct drm_plane *plane = state->planes[i]; |
||
146 | |||
147 | if (!plane) |
||
148 | continue; |
||
149 | |||
150 | plane->funcs->atomic_destroy_state(plane, |
||
151 | state->plane_states[i]); |
||
152 | } |
||
153 | } |
||
154 | EXPORT_SYMBOL(drm_atomic_state_clear); |
||
155 | |||
156 | /** |
||
157 | * drm_atomic_state_free - free all memory for an atomic state |
||
158 | * @state: atomic state to deallocate |
||
159 | * |
||
160 | * This frees all memory associated with an atomic state, including all the |
||
161 | * per-object state for planes, crtcs and connectors. |
||
162 | */ |
||
163 | void drm_atomic_state_free(struct drm_atomic_state *state) |
||
164 | { |
||
165 | drm_atomic_state_clear(state); |
||
166 | |||
167 | DRM_DEBUG_KMS("Freeing atomic state %p\n", state); |
||
168 | |||
169 | kfree_state(state); |
||
170 | } |
||
171 | EXPORT_SYMBOL(drm_atomic_state_free); |
||
172 | |||
173 | /** |
||
174 | * drm_atomic_get_crtc_state - get crtc state |
||
175 | * @state: global atomic state object |
||
176 | * @crtc: crtc to get state object for |
||
177 | * |
||
178 | * This function returns the crtc state for the given crtc, allocating it if |
||
179 | * needed. It will also grab the relevant crtc lock to make sure that the state |
||
180 | * is consistent. |
||
181 | * |
||
182 | * Returns: |
||
183 | * |
||
184 | * Either the allocated state or the error code encoded into the pointer. When |
||
185 | * the error is EDEADLK then the w/w mutex code has detected a deadlock and the |
||
186 | * entire atomic sequence must be restarted. All other errors are fatal. |
||
187 | */ |
||
188 | struct drm_crtc_state * |
||
189 | drm_atomic_get_crtc_state(struct drm_atomic_state *state, |
||
190 | struct drm_crtc *crtc) |
||
191 | { |
||
192 | int ret, index; |
||
193 | struct drm_crtc_state *crtc_state; |
||
194 | |||
195 | index = drm_crtc_index(crtc); |
||
196 | |||
197 | if (state->crtc_states[index]) |
||
198 | return state->crtc_states[index]; |
||
199 | |||
200 | ret = drm_modeset_lock(&crtc->mutex, state->acquire_ctx); |
||
201 | if (ret) |
||
202 | return ERR_PTR(ret); |
||
203 | |||
204 | crtc_state = crtc->funcs->atomic_duplicate_state(crtc); |
||
205 | if (!crtc_state) |
||
206 | return ERR_PTR(-ENOMEM); |
||
207 | |||
208 | state->crtc_states[index] = crtc_state; |
||
209 | state->crtcs[index] = crtc; |
||
210 | crtc_state->state = state; |
||
211 | |||
212 | DRM_DEBUG_KMS("Added [CRTC:%d] %p state to %p\n", |
||
213 | crtc->base.id, crtc_state, state); |
||
214 | |||
215 | return crtc_state; |
||
216 | } |
||
217 | EXPORT_SYMBOL(drm_atomic_get_crtc_state); |
||
218 | |||
219 | /** |
||
220 | * drm_atomic_get_plane_state - get plane state |
||
221 | * @state: global atomic state object |
||
222 | * @plane: plane to get state object for |
||
223 | * |
||
224 | * This function returns the plane state for the given plane, allocating it if |
||
225 | * needed. It will also grab the relevant plane lock to make sure that the state |
||
226 | * is consistent. |
||
227 | * |
||
228 | * Returns: |
||
229 | * |
||
230 | * Either the allocated state or the error code encoded into the pointer. When |
||
231 | * the error is EDEADLK then the w/w mutex code has detected a deadlock and the |
||
232 | * entire atomic sequence must be restarted. All other errors are fatal. |
||
233 | */ |
||
234 | struct drm_plane_state * |
||
235 | drm_atomic_get_plane_state(struct drm_atomic_state *state, |
||
236 | struct drm_plane *plane) |
||
237 | { |
||
238 | int ret, index; |
||
239 | struct drm_plane_state *plane_state; |
||
240 | |||
241 | index = drm_plane_index(plane); |
||
242 | |||
243 | if (state->plane_states[index]) |
||
244 | return state->plane_states[index]; |
||
245 | |||
246 | ret = drm_modeset_lock(&plane->mutex, state->acquire_ctx); |
||
247 | if (ret) |
||
248 | return ERR_PTR(ret); |
||
249 | |||
250 | plane_state = plane->funcs->atomic_duplicate_state(plane); |
||
251 | if (!plane_state) |
||
252 | return ERR_PTR(-ENOMEM); |
||
253 | |||
254 | state->plane_states[index] = plane_state; |
||
255 | state->planes[index] = plane; |
||
256 | plane_state->state = state; |
||
257 | |||
258 | DRM_DEBUG_KMS("Added [PLANE:%d] %p state to %p\n", |
||
259 | plane->base.id, plane_state, state); |
||
260 | |||
261 | if (plane_state->crtc) { |
||
262 | struct drm_crtc_state *crtc_state; |
||
263 | |||
264 | crtc_state = drm_atomic_get_crtc_state(state, |
||
265 | plane_state->crtc); |
||
266 | if (IS_ERR(crtc_state)) |
||
267 | return ERR_CAST(crtc_state); |
||
268 | } |
||
269 | |||
270 | return plane_state; |
||
271 | } |
||
272 | EXPORT_SYMBOL(drm_atomic_get_plane_state); |
||
273 | |||
274 | /** |
||
275 | * drm_atomic_get_connector_state - get connector state |
||
276 | * @state: global atomic state object |
||
277 | * @connector: connector to get state object for |
||
278 | * |
||
279 | * This function returns the connector state for the given connector, |
||
280 | * allocating it if needed. It will also grab the relevant connector lock to |
||
281 | * make sure that the state is consistent. |
||
282 | * |
||
283 | * Returns: |
||
284 | * |
||
285 | * Either the allocated state or the error code encoded into the pointer. When |
||
286 | * the error is EDEADLK then the w/w mutex code has detected a deadlock and the |
||
287 | * entire atomic sequence must be restarted. All other errors are fatal. |
||
288 | */ |
||
289 | struct drm_connector_state * |
||
290 | drm_atomic_get_connector_state(struct drm_atomic_state *state, |
||
291 | struct drm_connector *connector) |
||
292 | { |
||
293 | int ret, index; |
||
294 | struct drm_mode_config *config = &connector->dev->mode_config; |
||
295 | struct drm_connector_state *connector_state; |
||
296 | |||
297 | ret = drm_modeset_lock(&config->connection_mutex, state->acquire_ctx); |
||
298 | if (ret) |
||
299 | return ERR_PTR(ret); |
||
300 | |||
301 | index = drm_connector_index(connector); |
||
302 | |||
303 | /* |
||
304 | * Construction of atomic state updates can race with a connector |
||
305 | * hot-add which might overflow. In this case flip the table and just |
||
306 | * restart the entire ioctl - no one is fast enough to livelock a cpu |
||
307 | * with physical hotplug events anyway. |
||
308 | * |
||
309 | * Note that we only grab the indexes once we have the right lock to |
||
310 | * prevent hotplug/unplugging of connectors. So removal is no problem, |
||
311 | * at most the array is a bit too large. |
||
312 | */ |
||
313 | if (index >= state->num_connector) { |
||
314 | DRM_DEBUG_KMS("Hot-added connector would overflow state array, restarting\n"); |
||
315 | return ERR_PTR(-EAGAIN); |
||
316 | } |
||
317 | |||
318 | if (state->connector_states[index]) |
||
319 | return state->connector_states[index]; |
||
320 | |||
321 | connector_state = connector->funcs->atomic_duplicate_state(connector); |
||
322 | if (!connector_state) |
||
323 | return ERR_PTR(-ENOMEM); |
||
324 | |||
325 | state->connector_states[index] = connector_state; |
||
326 | state->connectors[index] = connector; |
||
327 | connector_state->state = state; |
||
328 | |||
329 | DRM_DEBUG_KMS("Added [CONNECTOR:%d] %p state to %p\n", |
||
330 | connector->base.id, connector_state, state); |
||
331 | |||
332 | if (connector_state->crtc) { |
||
333 | struct drm_crtc_state *crtc_state; |
||
334 | |||
335 | crtc_state = drm_atomic_get_crtc_state(state, |
||
336 | connector_state->crtc); |
||
337 | if (IS_ERR(crtc_state)) |
||
338 | return ERR_CAST(crtc_state); |
||
339 | } |
||
340 | |||
341 | return connector_state; |
||
342 | } |
||
343 | EXPORT_SYMBOL(drm_atomic_get_connector_state); |
||
344 | |||
345 | /** |
||
346 | * drm_atomic_set_crtc_for_plane - set crtc for plane |
||
347 | * @state: the incoming atomic state |
||
348 | * @plane: the plane whose incoming state to update |
||
349 | * @crtc: crtc to use for the plane |
||
350 | * |
||
351 | * Changing the assigned crtc for a plane requires us to grab the lock and state |
||
352 | * for the new crtc, as needed. This function takes care of all these details |
||
353 | * besides updating the pointer in the state object itself. |
||
354 | * |
||
355 | * Returns: |
||
356 | * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK |
||
357 | * then the w/w mutex code has detected a deadlock and the entire atomic |
||
358 | * sequence must be restarted. All other errors are fatal. |
||
359 | */ |
||
360 | int |
||
361 | drm_atomic_set_crtc_for_plane(struct drm_atomic_state *state, |
||
362 | struct drm_plane *plane, struct drm_crtc *crtc) |
||
363 | { |
||
364 | struct drm_plane_state *plane_state = |
||
365 | drm_atomic_get_plane_state(state, plane); |
||
366 | struct drm_crtc_state *crtc_state; |
||
367 | |||
368 | if (WARN_ON(IS_ERR(plane_state))) |
||
369 | return PTR_ERR(plane_state); |
||
370 | |||
371 | if (plane_state->crtc) { |
||
372 | crtc_state = drm_atomic_get_crtc_state(plane_state->state, |
||
373 | plane_state->crtc); |
||
374 | if (WARN_ON(IS_ERR(crtc_state))) |
||
375 | return PTR_ERR(crtc_state); |
||
376 | |||
377 | crtc_state->plane_mask &= ~(1 << drm_plane_index(plane)); |
||
378 | } |
||
379 | |||
380 | plane_state->crtc = crtc; |
||
381 | |||
382 | if (crtc) { |
||
383 | crtc_state = drm_atomic_get_crtc_state(plane_state->state, |
||
384 | crtc); |
||
385 | if (IS_ERR(crtc_state)) |
||
386 | return PTR_ERR(crtc_state); |
||
387 | crtc_state->plane_mask |= (1 << drm_plane_index(plane)); |
||
388 | } |
||
389 | |||
390 | if (crtc) |
||
391 | DRM_DEBUG_KMS("Link plane state %p to [CRTC:%d]\n", |
||
392 | plane_state, crtc->base.id); |
||
393 | else |
||
394 | DRM_DEBUG_KMS("Link plane state %p to [NOCRTC]\n", plane_state); |
||
395 | |||
396 | return 0; |
||
397 | } |
||
398 | EXPORT_SYMBOL(drm_atomic_set_crtc_for_plane); |
||
399 | |||
400 | /** |
||
401 | * drm_atomic_set_fb_for_plane - set crtc for plane |
||
402 | * @plane_state: atomic state object for the plane |
||
403 | * @fb: fb to use for the plane |
||
404 | * |
||
405 | * Changing the assigned framebuffer for a plane requires us to grab a reference |
||
406 | * to the new fb and drop the reference to the old fb, if there is one. This |
||
407 | * function takes care of all these details besides updating the pointer in the |
||
408 | * state object itself. |
||
409 | */ |
||
410 | void |
||
411 | drm_atomic_set_fb_for_plane(struct drm_plane_state *plane_state, |
||
412 | struct drm_framebuffer *fb) |
||
413 | { |
||
414 | if (plane_state->fb) |
||
415 | drm_framebuffer_unreference(plane_state->fb); |
||
416 | if (fb) |
||
417 | drm_framebuffer_reference(fb); |
||
418 | plane_state->fb = fb; |
||
419 | |||
420 | if (fb) |
||
421 | DRM_DEBUG_KMS("Set [FB:%d] for plane state %p\n", |
||
422 | fb->base.id, plane_state); |
||
423 | else |
||
424 | DRM_DEBUG_KMS("Set [NOFB] for plane state %p\n", plane_state); |
||
425 | } |
||
426 | EXPORT_SYMBOL(drm_atomic_set_fb_for_plane); |
||
427 | |||
428 | /** |
||
429 | * drm_atomic_set_crtc_for_connector - set crtc for connector |
||
430 | * @conn_state: atomic state object for the connector |
||
431 | * @crtc: crtc to use for the connector |
||
432 | * |
||
433 | * Changing the assigned crtc for a connector requires us to grab the lock and |
||
434 | * state for the new crtc, as needed. This function takes care of all these |
||
435 | * details besides updating the pointer in the state object itself. |
||
436 | * |
||
437 | * Returns: |
||
438 | * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK |
||
439 | * then the w/w mutex code has detected a deadlock and the entire atomic |
||
440 | * sequence must be restarted. All other errors are fatal. |
||
441 | */ |
||
442 | int |
||
443 | drm_atomic_set_crtc_for_connector(struct drm_connector_state *conn_state, |
||
444 | struct drm_crtc *crtc) |
||
445 | { |
||
446 | struct drm_crtc_state *crtc_state; |
||
447 | |||
448 | if (crtc) { |
||
449 | crtc_state = drm_atomic_get_crtc_state(conn_state->state, crtc); |
||
450 | if (IS_ERR(crtc_state)) |
||
451 | return PTR_ERR(crtc_state); |
||
452 | } |
||
453 | |||
454 | conn_state->crtc = crtc; |
||
455 | |||
456 | if (crtc) |
||
457 | DRM_DEBUG_KMS("Link connector state %p to [CRTC:%d]\n", |
||
458 | conn_state, crtc->base.id); |
||
459 | else |
||
460 | DRM_DEBUG_KMS("Link connector state %p to [NOCRTC]\n", |
||
461 | conn_state); |
||
462 | |||
463 | return 0; |
||
464 | } |
||
465 | EXPORT_SYMBOL(drm_atomic_set_crtc_for_connector); |
||
466 | |||
467 | /** |
||
468 | * drm_atomic_add_affected_connectors - add connectors for crtc |
||
469 | * @state: atomic state |
||
470 | * @crtc: DRM crtc |
||
471 | * |
||
472 | * This function walks the current configuration and adds all connectors |
||
473 | * currently using @crtc to the atomic configuration @state. Note that this |
||
474 | * function must acquire the connection mutex. This can potentially cause |
||
475 | * unneeded seralization if the update is just for the planes on one crtc. Hence |
||
476 | * drivers and helpers should only call this when really needed (e.g. when a |
||
477 | * full modeset needs to happen due to some change). |
||
478 | * |
||
479 | * Returns: |
||
480 | * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK |
||
481 | * then the w/w mutex code has detected a deadlock and the entire atomic |
||
482 | * sequence must be restarted. All other errors are fatal. |
||
483 | */ |
||
484 | int |
||
485 | drm_atomic_add_affected_connectors(struct drm_atomic_state *state, |
||
486 | struct drm_crtc *crtc) |
||
487 | { |
||
488 | struct drm_mode_config *config = &state->dev->mode_config; |
||
489 | struct drm_connector *connector; |
||
490 | struct drm_connector_state *conn_state; |
||
491 | int ret; |
||
492 | |||
493 | ret = drm_modeset_lock(&config->connection_mutex, state->acquire_ctx); |
||
494 | if (ret) |
||
495 | return ret; |
||
496 | |||
497 | DRM_DEBUG_KMS("Adding all current connectors for [CRTC:%d] to %p\n", |
||
498 | crtc->base.id, state); |
||
499 | |||
500 | /* |
||
501 | * Changed connectors are already in @state, so only need to look at the |
||
502 | * current configuration. |
||
503 | */ |
||
504 | list_for_each_entry(connector, &config->connector_list, head) { |
||
505 | if (connector->state->crtc != crtc) |
||
506 | continue; |
||
507 | |||
508 | conn_state = drm_atomic_get_connector_state(state, connector); |
||
509 | if (IS_ERR(conn_state)) |
||
510 | return PTR_ERR(conn_state); |
||
511 | } |
||
512 | |||
513 | return 0; |
||
514 | } |
||
515 | EXPORT_SYMBOL(drm_atomic_add_affected_connectors); |
||
516 | |||
517 | /** |
||
518 | * drm_atomic_connectors_for_crtc - count number of connected outputs |
||
519 | * @state: atomic state |
||
520 | * @crtc: DRM crtc |
||
521 | * |
||
522 | * This function counts all connectors which will be connected to @crtc |
||
523 | * according to @state. Useful to recompute the enable state for @crtc. |
||
524 | */ |
||
525 | int |
||
526 | drm_atomic_connectors_for_crtc(struct drm_atomic_state *state, |
||
527 | struct drm_crtc *crtc) |
||
528 | { |
||
529 | int i, num_connected_connectors = 0; |
||
530 | |||
531 | for (i = 0; i < state->num_connector; i++) { |
||
532 | struct drm_connector_state *conn_state; |
||
533 | |||
534 | conn_state = state->connector_states[i]; |
||
535 | |||
536 | if (conn_state && conn_state->crtc == crtc) |
||
537 | num_connected_connectors++; |
||
538 | } |
||
539 | |||
540 | DRM_DEBUG_KMS("State %p has %i connectors for [CRTC:%d]\n", |
||
541 | state, num_connected_connectors, crtc->base.id); |
||
542 | |||
543 | return num_connected_connectors; |
||
544 | } |
||
545 | EXPORT_SYMBOL(drm_atomic_connectors_for_crtc); |
||
546 | |||
547 | /** |
||
548 | * drm_atomic_legacy_backoff - locking backoff for legacy ioctls |
||
549 | * @state: atomic state |
||
550 | * |
||
551 | * This function should be used by legacy entry points which don't understand |
||
552 | * -EDEADLK semantics. For simplicity this one will grab all modeset locks after |
||
553 | * the slowpath completed. |
||
554 | */ |
||
555 | void drm_atomic_legacy_backoff(struct drm_atomic_state *state) |
||
556 | { |
||
557 | int ret; |
||
558 | |||
559 | retry: |
||
560 | drm_modeset_backoff(state->acquire_ctx); |
||
561 | |||
562 | ret = drm_modeset_lock(&state->dev->mode_config.connection_mutex, |
||
563 | state->acquire_ctx); |
||
564 | if (ret) |
||
565 | goto retry; |
||
566 | ret = drm_modeset_lock_all_crtcs(state->dev, |
||
567 | state->acquire_ctx); |
||
568 | if (ret) |
||
569 | goto retry; |
||
570 | } |
||
571 | EXPORT_SYMBOL(drm_atomic_legacy_backoff); |
||
572 | |||
573 | /** |
||
574 | * drm_atomic_check_only - check whether a given config would work |
||
575 | * @state: atomic configuration to check |
||
576 | * |
||
577 | * Note that this function can return -EDEADLK if the driver needed to acquire |
||
578 | * more locks but encountered a deadlock. The caller must then do the usual w/w |
||
579 | * backoff dance and restart. All other errors are fatal. |
||
580 | * |
||
581 | * Returns: |
||
582 | * 0 on success, negative error code on failure. |
||
583 | */ |
||
584 | int drm_atomic_check_only(struct drm_atomic_state *state) |
||
585 | { |
||
586 | struct drm_mode_config *config = &state->dev->mode_config; |
||
587 | |||
588 | DRM_DEBUG_KMS("checking %p\n", state); |
||
589 | |||
590 | if (config->funcs->atomic_check) |
||
591 | return config->funcs->atomic_check(state->dev, state); |
||
592 | else |
||
593 | return 0; |
||
594 | } |
||
595 | EXPORT_SYMBOL(drm_atomic_check_only); |
||
596 | |||
597 | /** |
||
598 | * drm_atomic_commit - commit configuration atomically |
||
599 | * @state: atomic configuration to check |
||
600 | * |
||
601 | * Note that this function can return -EDEADLK if the driver needed to acquire |
||
602 | * more locks but encountered a deadlock. The caller must then do the usual w/w |
||
603 | * backoff dance and restart. All other errors are fatal. |
||
604 | * |
||
605 | * Also note that on successful execution ownership of @state is transferred |
||
606 | * from the caller of this function to the function itself. The caller must not |
||
607 | * free or in any other way access @state. If the function fails then the caller |
||
608 | * must clean up @state itself. |
||
609 | * |
||
610 | * Returns: |
||
611 | * 0 on success, negative error code on failure. |
||
612 | */ |
||
613 | int drm_atomic_commit(struct drm_atomic_state *state) |
||
614 | { |
||
615 | struct drm_mode_config *config = &state->dev->mode_config; |
||
616 | int ret; |
||
617 | |||
618 | ret = drm_atomic_check_only(state); |
||
619 | if (ret) |
||
620 | return ret; |
||
621 | |||
622 | DRM_DEBUG_KMS("commiting %p\n", state); |
||
623 | |||
624 | return config->funcs->atomic_commit(state->dev, state, false); |
||
625 | } |
||
626 | EXPORT_SYMBOL(drm_atomic_commit); |
||
627 | |||
628 | /** |
||
629 | * drm_atomic_async_commit - atomic&async configuration commit |
||
630 | * @state: atomic configuration to check |
||
631 | * |
||
632 | * Note that this function can return -EDEADLK if the driver needed to acquire |
||
633 | * more locks but encountered a deadlock. The caller must then do the usual w/w |
||
634 | * backoff dance and restart. All other errors are fatal. |
||
635 | * |
||
636 | * Also note that on successful execution ownership of @state is transferred |
||
637 | * from the caller of this function to the function itself. The caller must not |
||
638 | * free or in any other way access @state. If the function fails then the caller |
||
639 | * must clean up @state itself. |
||
640 | * |
||
641 | * Returns: |
||
642 | * 0 on success, negative error code on failure. |
||
643 | */ |
||
644 | int drm_atomic_async_commit(struct drm_atomic_state *state) |
||
645 | { |
||
646 | struct drm_mode_config *config = &state->dev->mode_config; |
||
647 | int ret; |
||
648 | |||
649 | ret = drm_atomic_check_only(state); |
||
650 | if (ret) |
||
651 | return ret; |
||
652 | |||
653 | DRM_DEBUG_KMS("commiting %p asynchronously\n", state); |
||
654 | |||
655 | return config->funcs->atomic_commit(state->dev, state, true); |
||
656 | } |
||
657 | EXPORT_SYMBOL(drm_atomic_async_commit); |
||
658 | |||
659 | /** |
||
660 | * drm_atomic_helper_plane_duplicate_state - default state duplicate hook |
||
661 | * @plane: drm plane |
||
662 | * |
||
663 | * Default plane state duplicate hook for drivers which don't have their own |
||
664 | * subclassed plane state structure. |
||
665 | */ |
||
666 | struct drm_plane_state * |
||
667 | drm_atomic_helper_plane_duplicate_state(struct drm_plane *plane) |
||
668 | { |
||
669 | struct drm_plane_state *state; |
||
670 | |||
671 | if (WARN_ON(!plane->state)) |
||
672 | return NULL; |
||
673 | |||
674 | state = kmemdup(plane->state, sizeof(*plane->state), GFP_KERNEL); |
||
675 | |||
676 | if (state && state->fb) |
||
677 | drm_framebuffer_reference(state->fb); |
||
678 | |||
679 | return state; |
||
680 | } |
||
681 | EXPORT_SYMBOL(drm_atomic_helper_plane_duplicate_state); |
||
682 | |||
683 | |||
684 | /** |
||
685 | * drm_atomic_helper_crtc_destroy_state - default state destroy hook |
||
686 | * @crtc: drm CRTC |
||
687 | * @state: CRTC state object to release |
||
688 | * |
||
689 | * Default CRTC state destroy hook for drivers which don't have their own |
||
690 | * subclassed CRTC state structure. |
||
691 | */ |
||
692 | void drm_atomic_helper_crtc_destroy_state(struct drm_crtc *crtc, |
||
693 | struct drm_crtc_state *state) |
||
694 | { |
||
695 | kfree(state); |
||
696 | } |
||
697 | EXPORT_SYMBOL(drm_atomic_helper_crtc_destroy_state); |
||
698 | |||
699 | /** |
||
700 | * drm_atomic_helper_plane_destroy_state - default state destroy hook |
||
701 | * @plane: drm plane |
||
702 | * @state: plane state object to release |
||
703 | * |
||
704 | * Default plane state destroy hook for drivers which don't have their own |
||
705 | * subclassed plane state structure. |
||
706 | */ |
||
707 | void drm_atomic_helper_plane_destroy_state(struct drm_plane *plane, |
||
708 | struct drm_plane_state *state) |
||
709 | { |
||
710 | if (state->fb) |
||
711 | drm_framebuffer_unreference(state->fb); |
||
712 | |||
713 | kfree(state); |
||
714 | } |
||
715 | EXPORT_SYMBOL(drm_atomic_helper_plane_destroy_state);>><>><>>>> |