Branch data Line data Source code
1 : : /*
2 : : * Copyright (C) 2014 Red Hat
3 : : * Copyright (C) 2014 Intel Corp.
4 : : *
5 : : * Permission is hereby granted, free of charge, to any person obtaining a
6 : : * copy of this software and associated documentation files (the "Software"),
7 : : * to deal in the Software without restriction, including without limitation
8 : : * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 : : * and/or sell copies of the Software, and to permit persons to whom the
10 : : * Software is furnished to do so, subject to the following conditions:
11 : : *
12 : : * The above copyright notice and this permission notice shall be included in
13 : : * all copies or substantial portions of the Software.
14 : : *
15 : : * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 : : * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 : : * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 : : * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
19 : : * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
20 : : * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
21 : : * OTHER DEALINGS IN THE SOFTWARE.
22 : : *
23 : : * Authors:
24 : : * Rob Clark <robdclark@gmail.com>
25 : : * Daniel Vetter <daniel.vetter@ffwll.ch>
26 : : */
27 : :
28 : : #ifndef DRM_ATOMIC_H_
29 : : #define DRM_ATOMIC_H_
30 : :
31 : : #include <drm/drm_crtc.h>
32 : : #include <drm/drm_util.h>
33 : :
34 : : /**
35 : : * struct drm_crtc_commit - track modeset commits on a CRTC
36 : : *
37 : : * This structure is used to track pending modeset changes and atomic commit on
38 : : * a per-CRTC basis. Since updating the list should never block, this structure
39 : : * is reference counted to allow waiters to safely wait on an event to complete,
40 : : * without holding any locks.
41 : : *
42 : : * It has 3 different events in total to allow a fine-grained synchronization
43 : : * between outstanding updates::
44 : : *
45 : : * atomic commit thread hardware
46 : : *
47 : : * write new state into hardware ----> ...
48 : : * signal hw_done
49 : : * switch to new state on next
50 : : * ... v/hblank
51 : : *
52 : : * wait for buffers to show up ...
53 : : *
54 : : * ... send completion irq
55 : : * irq handler signals flip_done
56 : : * cleanup old buffers
57 : : *
58 : : * signal cleanup_done
59 : : *
60 : : * wait for flip_done <----
61 : : * clean up atomic state
62 : : *
63 : : * The important bit to know is that &cleanup_done is the terminal event, but the
64 : : * ordering between &flip_done and &hw_done is entirely up to the specific driver
65 : : * and modeset state change.
66 : : *
67 : : * For an implementation of how to use this look at
68 : : * drm_atomic_helper_setup_commit() from the atomic helper library.
69 : : */
70 : : struct drm_crtc_commit {
71 : : /**
72 : : * @crtc:
73 : : *
74 : : * DRM CRTC for this commit.
75 : : */
76 : : struct drm_crtc *crtc;
77 : :
78 : : /**
79 : : * @ref:
80 : : *
81 : : * Reference count for this structure. Needed to allow blocking on
82 : : * completions without the risk of the completion disappearing
83 : : * meanwhile.
84 : : */
85 : : struct kref ref;
86 : :
87 : : /**
88 : : * @flip_done:
89 : : *
90 : : * Will be signaled when the hardware has flipped to the new set of
91 : : * buffers. Signals at the same time as when the drm event for this
92 : : * commit is sent to userspace, or when an out-fence is singalled. Note
93 : : * that for most hardware, in most cases this happens after @hw_done is
94 : : * signalled.
95 : : *
96 : : * Completion of this stage is signalled implicitly by calling
97 : : * drm_crtc_send_vblank_event() on &drm_crtc_state.event.
98 : : */
99 : : struct completion flip_done;
100 : :
101 : : /**
102 : : * @hw_done:
103 : : *
104 : : * Will be signalled when all hw register changes for this commit have
105 : : * been written out. Especially when disabling a pipe this can be much
106 : : * later than than @flip_done, since that can signal already when the
107 : : * screen goes black, whereas to fully shut down a pipe more register
108 : : * I/O is required.
109 : : *
110 : : * Note that this does not need to include separately reference-counted
111 : : * resources like backing storage buffer pinning, or runtime pm
112 : : * management.
113 : : *
114 : : * Drivers should call drm_atomic_helper_commit_hw_done() to signal
115 : : * completion of this stage.
116 : : */
117 : : struct completion hw_done;
118 : :
119 : : /**
120 : : * @cleanup_done:
121 : : *
122 : : * Will be signalled after old buffers have been cleaned up by calling
123 : : * drm_atomic_helper_cleanup_planes(). Since this can only happen after
124 : : * a vblank wait completed it might be a bit later. This completion is
125 : : * useful to throttle updates and avoid hardware updates getting ahead
126 : : * of the buffer cleanup too much.
127 : : *
128 : : * Drivers should call drm_atomic_helper_commit_cleanup_done() to signal
129 : : * completion of this stage.
130 : : */
131 : : struct completion cleanup_done;
132 : :
133 : : /**
134 : : * @commit_entry:
135 : : *
136 : : * Entry on the per-CRTC &drm_crtc.commit_list. Protected by
137 : : * $drm_crtc.commit_lock.
138 : : */
139 : : struct list_head commit_entry;
140 : :
141 : : /**
142 : : * @event:
143 : : *
144 : : * &drm_pending_vblank_event pointer to clean up private events.
145 : : */
146 : : struct drm_pending_vblank_event *event;
147 : :
148 : : /**
149 : : * @abort_completion:
150 : : *
151 : : * A flag that's set after drm_atomic_helper_setup_commit() takes a
152 : : * second reference for the completion of $drm_crtc_state.event. It's
153 : : * used by the free code to remove the second reference if commit fails.
154 : : */
155 : : bool abort_completion;
156 : : };
157 : :
158 : : struct __drm_planes_state {
159 : : struct drm_plane *ptr;
160 : : struct drm_plane_state *state, *old_state, *new_state;
161 : : };
162 : :
163 : : struct __drm_crtcs_state {
164 : : struct drm_crtc *ptr;
165 : : struct drm_crtc_state *state, *old_state, *new_state;
166 : :
167 : : /**
168 : : * @commit:
169 : : *
170 : : * A reference to the CRTC commit object that is kept for use by
171 : : * drm_atomic_helper_wait_for_flip_done() after
172 : : * drm_atomic_helper_commit_hw_done() is called. This ensures that a
173 : : * concurrent commit won't free a commit object that is still in use.
174 : : */
175 : : struct drm_crtc_commit *commit;
176 : :
177 : : s32 __user *out_fence_ptr;
178 : : u64 last_vblank_count;
179 : : };
180 : :
181 : : struct __drm_connnectors_state {
182 : : struct drm_connector *ptr;
183 : : struct drm_connector_state *state, *old_state, *new_state;
184 : : /**
185 : : * @out_fence_ptr:
186 : : *
187 : : * User-provided pointer which the kernel uses to return a sync_file
188 : : * file descriptor. Used by writeback connectors to signal completion of
189 : : * the writeback.
190 : : */
191 : : s32 __user *out_fence_ptr;
192 : : };
193 : :
194 : : struct drm_private_obj;
195 : : struct drm_private_state;
196 : :
197 : : /**
198 : : * struct drm_private_state_funcs - atomic state functions for private objects
199 : : *
200 : : * These hooks are used by atomic helpers to create, swap and destroy states of
201 : : * private objects. The structure itself is used as a vtable to identify the
202 : : * associated private object type. Each private object type that needs to be
203 : : * added to the atomic states is expected to have an implementation of these
204 : : * hooks and pass a pointer to its drm_private_state_funcs struct to
205 : : * drm_atomic_get_private_obj_state().
206 : : */
207 : : struct drm_private_state_funcs {
208 : : /**
209 : : * @atomic_duplicate_state:
210 : : *
211 : : * Duplicate the current state of the private object and return it. It
212 : : * is an error to call this before obj->state has been initialized.
213 : : *
214 : : * RETURNS:
215 : : *
216 : : * Duplicated atomic state or NULL when obj->state is not
217 : : * initialized or allocation failed.
218 : : */
219 : : struct drm_private_state *(*atomic_duplicate_state)(struct drm_private_obj *obj);
220 : :
221 : : /**
222 : : * @atomic_destroy_state:
223 : : *
224 : : * Frees the private object state created with @atomic_duplicate_state.
225 : : */
226 : : void (*atomic_destroy_state)(struct drm_private_obj *obj,
227 : : struct drm_private_state *state);
228 : : };
229 : :
230 : : /**
231 : : * struct drm_private_obj - base struct for driver private atomic object
232 : : *
233 : : * A driver private object is initialized by calling
234 : : * drm_atomic_private_obj_init() and cleaned up by calling
235 : : * drm_atomic_private_obj_fini().
236 : : *
237 : : * Currently only tracks the state update functions and the opaque driver
238 : : * private state itself, but in the future might also track which
239 : : * &drm_modeset_lock is required to duplicate and update this object's state.
240 : : *
241 : : * All private objects must be initialized before the DRM device they are
242 : : * attached to is registered to the DRM subsystem (call to drm_dev_register())
243 : : * and should stay around until this DRM device is unregistered (call to
244 : : * drm_dev_unregister()). In other words, private objects lifetime is tied
245 : : * to the DRM device lifetime. This implies that:
246 : : *
247 : : * 1/ all calls to drm_atomic_private_obj_init() must be done before calling
248 : : * drm_dev_register()
249 : : * 2/ all calls to drm_atomic_private_obj_fini() must be done after calling
250 : : * drm_dev_unregister()
251 : : */
252 : : struct drm_private_obj {
253 : : /**
254 : : * @head: List entry used to attach a private object to a &drm_device
255 : : * (queued to &drm_mode_config.privobj_list).
256 : : */
257 : : struct list_head head;
258 : :
259 : : /**
260 : : * @lock: Modeset lock to protect the state object.
261 : : */
262 : : struct drm_modeset_lock lock;
263 : :
264 : : /**
265 : : * @state: Current atomic state for this driver private object.
266 : : */
267 : : struct drm_private_state *state;
268 : :
269 : : /**
270 : : * @funcs:
271 : : *
272 : : * Functions to manipulate the state of this driver private object, see
273 : : * &drm_private_state_funcs.
274 : : */
275 : : const struct drm_private_state_funcs *funcs;
276 : : };
277 : :
278 : : /**
279 : : * drm_for_each_privobj() - private object iterator
280 : : *
281 : : * @privobj: pointer to the current private object. Updated after each
282 : : * iteration
283 : : * @dev: the DRM device we want get private objects from
284 : : *
285 : : * Allows one to iterate over all private objects attached to @dev
286 : : */
287 : : #define drm_for_each_privobj(privobj, dev) \
288 : : list_for_each_entry(privobj, &(dev)->mode_config.privobj_list, head)
289 : :
290 : : /**
291 : : * struct drm_private_state - base struct for driver private object state
292 : : * @state: backpointer to global drm_atomic_state
293 : : *
294 : : * Currently only contains a backpointer to the overall atomic update, but in
295 : : * the future also might hold synchronization information similar to e.g.
296 : : * &drm_crtc.commit.
297 : : */
298 : : struct drm_private_state {
299 : : struct drm_atomic_state *state;
300 : : };
301 : :
302 : : struct __drm_private_objs_state {
303 : : struct drm_private_obj *ptr;
304 : : struct drm_private_state *state, *old_state, *new_state;
305 : : };
306 : :
307 : : /**
308 : : * struct drm_atomic_state - the global state object for atomic updates
309 : : * @ref: count of all references to this state (will not be freed until zero)
310 : : * @dev: parent DRM device
311 : : * @legacy_cursor_update: hint to enforce legacy cursor IOCTL semantics
312 : : * @async_update: hint for asynchronous plane update
313 : : * @planes: pointer to array of structures with per-plane data
314 : : * @crtcs: pointer to array of CRTC pointers
315 : : * @num_connector: size of the @connectors and @connector_states arrays
316 : : * @connectors: pointer to array of structures with per-connector data
317 : : * @num_private_objs: size of the @private_objs array
318 : : * @private_objs: pointer to array of private object pointers
319 : : * @acquire_ctx: acquire context for this atomic modeset state update
320 : : *
321 : : * States are added to an atomic update by calling drm_atomic_get_crtc_state(),
322 : : * drm_atomic_get_plane_state(), drm_atomic_get_connector_state(), or for
323 : : * private state structures, drm_atomic_get_private_obj_state().
324 : : */
325 : : struct drm_atomic_state {
326 : : struct kref ref;
327 : :
328 : : struct drm_device *dev;
329 : :
330 : : /**
331 : : * @allow_modeset:
332 : : *
333 : : * Allow full modeset. This is used by the ATOMIC IOCTL handler to
334 : : * implement the DRM_MODE_ATOMIC_ALLOW_MODESET flag. Drivers should
335 : : * never consult this flag, instead looking at the output of
336 : : * drm_atomic_crtc_needs_modeset().
337 : : */
338 : : bool allow_modeset : 1;
339 : : bool legacy_cursor_update : 1;
340 : : bool async_update : 1;
341 : : /**
342 : : * @duplicated:
343 : : *
344 : : * Indicates whether or not this atomic state was duplicated using
345 : : * drm_atomic_helper_duplicate_state(). Drivers and atomic helpers
346 : : * should use this to fixup normal inconsistencies in duplicated
347 : : * states.
348 : : */
349 : : bool duplicated : 1;
350 : : struct __drm_planes_state *planes;
351 : : struct __drm_crtcs_state *crtcs;
352 : : int num_connector;
353 : : struct __drm_connnectors_state *connectors;
354 : : int num_private_objs;
355 : : struct __drm_private_objs_state *private_objs;
356 : :
357 : : struct drm_modeset_acquire_ctx *acquire_ctx;
358 : :
359 : : /**
360 : : * @fake_commit:
361 : : *
362 : : * Used for signaling unbound planes/connectors.
363 : : * When a connector or plane is not bound to any CRTC, it's still important
364 : : * to preserve linearity to prevent the atomic states from being freed to early.
365 : : *
366 : : * This commit (if set) is not bound to any CRTC, but will be completed when
367 : : * drm_atomic_helper_commit_hw_done() is called.
368 : : */
369 : : struct drm_crtc_commit *fake_commit;
370 : :
371 : : /**
372 : : * @commit_work:
373 : : *
374 : : * Work item which can be used by the driver or helpers to execute the
375 : : * commit without blocking.
376 : : */
377 : : struct work_struct commit_work;
378 : : };
379 : :
380 : : void __drm_crtc_commit_free(struct kref *kref);
381 : :
382 : : /**
383 : : * drm_crtc_commit_get - acquire a reference to the CRTC commit
384 : : * @commit: CRTC commit
385 : : *
386 : : * Increases the reference of @commit.
387 : : *
388 : : * Returns:
389 : : * The pointer to @commit, with reference increased.
390 : : */
391 : 0 : static inline struct drm_crtc_commit *drm_crtc_commit_get(struct drm_crtc_commit *commit)
392 : : {
393 : 0 : kref_get(&commit->ref);
394 [ # # ]: 0 : return commit;
395 : : }
396 : :
397 : : /**
398 : : * drm_crtc_commit_put - release a reference to the CRTC commmit
399 : : * @commit: CRTC commit
400 : : *
401 : : * This releases a reference to @commit which is freed after removing the
402 : : * final reference. No locking required and callable from any context.
403 : : */
404 : 0 : static inline void drm_crtc_commit_put(struct drm_crtc_commit *commit)
405 : : {
406 : 0 : kref_put(&commit->ref, __drm_crtc_commit_free);
407 : 0 : }
408 : :
409 : : struct drm_atomic_state * __must_check
410 : : drm_atomic_state_alloc(struct drm_device *dev);
411 : : void drm_atomic_state_clear(struct drm_atomic_state *state);
412 : :
413 : : /**
414 : : * drm_atomic_state_get - acquire a reference to the atomic state
415 : : * @state: The atomic state
416 : : *
417 : : * Returns a new reference to the @state
418 : : */
419 : : static inline struct drm_atomic_state *
420 : 0 : drm_atomic_state_get(struct drm_atomic_state *state)
421 : : {
422 : 0 : kref_get(&state->ref);
423 [ # # ]: 0 : return state;
424 : : }
425 : :
426 : : void __drm_atomic_state_free(struct kref *ref);
427 : :
428 : : /**
429 : : * drm_atomic_state_put - release a reference to the atomic state
430 : : * @state: The atomic state
431 : : *
432 : : * This releases a reference to @state which is freed after removing the
433 : : * final reference. No locking required and callable from any context.
434 : : */
435 : 0 : static inline void drm_atomic_state_put(struct drm_atomic_state *state)
436 : : {
437 : 0 : kref_put(&state->ref, __drm_atomic_state_free);
438 : 0 : }
439 : :
440 : : int __must_check
441 : : drm_atomic_state_init(struct drm_device *dev, struct drm_atomic_state *state);
442 : : void drm_atomic_state_default_clear(struct drm_atomic_state *state);
443 : : void drm_atomic_state_default_release(struct drm_atomic_state *state);
444 : :
445 : : struct drm_crtc_state * __must_check
446 : : drm_atomic_get_crtc_state(struct drm_atomic_state *state,
447 : : struct drm_crtc *crtc);
448 : : struct drm_plane_state * __must_check
449 : : drm_atomic_get_plane_state(struct drm_atomic_state *state,
450 : : struct drm_plane *plane);
451 : : struct drm_connector_state * __must_check
452 : : drm_atomic_get_connector_state(struct drm_atomic_state *state,
453 : : struct drm_connector *connector);
454 : :
455 : : void drm_atomic_private_obj_init(struct drm_device *dev,
456 : : struct drm_private_obj *obj,
457 : : struct drm_private_state *state,
458 : : const struct drm_private_state_funcs *funcs);
459 : : void drm_atomic_private_obj_fini(struct drm_private_obj *obj);
460 : :
461 : : struct drm_private_state * __must_check
462 : : drm_atomic_get_private_obj_state(struct drm_atomic_state *state,
463 : : struct drm_private_obj *obj);
464 : : struct drm_private_state *
465 : : drm_atomic_get_old_private_obj_state(struct drm_atomic_state *state,
466 : : struct drm_private_obj *obj);
467 : : struct drm_private_state *
468 : : drm_atomic_get_new_private_obj_state(struct drm_atomic_state *state,
469 : : struct drm_private_obj *obj);
470 : :
471 : : struct drm_connector *
472 : : drm_atomic_get_old_connector_for_encoder(struct drm_atomic_state *state,
473 : : struct drm_encoder *encoder);
474 : : struct drm_connector *
475 : : drm_atomic_get_new_connector_for_encoder(struct drm_atomic_state *state,
476 : : struct drm_encoder *encoder);
477 : :
478 : : /**
479 : : * drm_atomic_get_existing_crtc_state - get CRTC state, if it exists
480 : : * @state: global atomic state object
481 : : * @crtc: CRTC to grab
482 : : *
483 : : * This function returns the CRTC state for the given CRTC, or NULL
484 : : * if the CRTC is not part of the global atomic state.
485 : : *
486 : : * This function is deprecated, @drm_atomic_get_old_crtc_state or
487 : : * @drm_atomic_get_new_crtc_state should be used instead.
488 : : */
489 : : static inline struct drm_crtc_state *
490 : 0 : drm_atomic_get_existing_crtc_state(struct drm_atomic_state *state,
491 : : struct drm_crtc *crtc)
492 : : {
493 [ # # ]: 0 : return state->crtcs[drm_crtc_index(crtc)].state;
494 : : }
495 : :
496 : : /**
497 : : * drm_atomic_get_old_crtc_state - get old CRTC state, if it exists
498 : : * @state: global atomic state object
499 : : * @crtc: CRTC to grab
500 : : *
501 : : * This function returns the old CRTC state for the given CRTC, or
502 : : * NULL if the CRTC is not part of the global atomic state.
503 : : */
504 : : static inline struct drm_crtc_state *
505 : 0 : drm_atomic_get_old_crtc_state(struct drm_atomic_state *state,
506 : : struct drm_crtc *crtc)
507 : : {
508 [ # # # # : 0 : return state->crtcs[drm_crtc_index(crtc)].old_state;
# # # # #
# # # #
# ]
509 : : }
510 : : /**
511 : : * drm_atomic_get_new_crtc_state - get new CRTC state, if it exists
512 : : * @state: global atomic state object
513 : : * @crtc: CRTC to grab
514 : : *
515 : : * This function returns the new CRTC state for the given CRTC, or
516 : : * NULL if the CRTC is not part of the global atomic state.
517 : : */
518 : : static inline struct drm_crtc_state *
519 : 0 : drm_atomic_get_new_crtc_state(struct drm_atomic_state *state,
520 : : struct drm_crtc *crtc)
521 : : {
522 [ # # # # : 0 : return state->crtcs[drm_crtc_index(crtc)].new_state;
# # # # #
# # # # #
# # # # ]
523 : : }
524 : :
525 : : /**
526 : : * drm_atomic_get_existing_plane_state - get plane state, if it exists
527 : : * @state: global atomic state object
528 : : * @plane: plane to grab
529 : : *
530 : : * This function returns the plane state for the given plane, or NULL
531 : : * if the plane is not part of the global atomic state.
532 : : *
533 : : * This function is deprecated, @drm_atomic_get_old_plane_state or
534 : : * @drm_atomic_get_new_plane_state should be used instead.
535 : : */
536 : : static inline struct drm_plane_state *
537 : 0 : drm_atomic_get_existing_plane_state(struct drm_atomic_state *state,
538 : : struct drm_plane *plane)
539 : : {
540 [ # # ]: 0 : return state->planes[drm_plane_index(plane)].state;
541 : : }
542 : :
543 : : /**
544 : : * drm_atomic_get_old_plane_state - get plane state, if it exists
545 : : * @state: global atomic state object
546 : : * @plane: plane to grab
547 : : *
548 : : * This function returns the old plane state for the given plane, or
549 : : * NULL if the plane is not part of the global atomic state.
550 : : */
551 : : static inline struct drm_plane_state *
552 : 0 : drm_atomic_get_old_plane_state(struct drm_atomic_state *state,
553 : : struct drm_plane *plane)
554 : : {
555 [ # # ]: 0 : return state->planes[drm_plane_index(plane)].old_state;
556 : : }
557 : :
558 : : /**
559 : : * drm_atomic_get_new_plane_state - get plane state, if it exists
560 : : * @state: global atomic state object
561 : : * @plane: plane to grab
562 : : *
563 : : * This function returns the new plane state for the given plane, or
564 : : * NULL if the plane is not part of the global atomic state.
565 : : */
566 : : static inline struct drm_plane_state *
567 : 0 : drm_atomic_get_new_plane_state(struct drm_atomic_state *state,
568 : : struct drm_plane *plane)
569 : : {
570 [ # # # # : 0 : return state->planes[drm_plane_index(plane)].new_state;
# # ]
571 : : }
572 : :
573 : : /**
574 : : * drm_atomic_get_existing_connector_state - get connector state, if it exists
575 : : * @state: global atomic state object
576 : : * @connector: connector to grab
577 : : *
578 : : * This function returns the connector state for the given connector,
579 : : * or NULL if the connector is not part of the global atomic state.
580 : : *
581 : : * This function is deprecated, @drm_atomic_get_old_connector_state or
582 : : * @drm_atomic_get_new_connector_state should be used instead.
583 : : */
584 : : static inline struct drm_connector_state *
585 : : drm_atomic_get_existing_connector_state(struct drm_atomic_state *state,
586 : : struct drm_connector *connector)
587 : : {
588 : : int index = drm_connector_index(connector);
589 : :
590 : : if (index >= state->num_connector)
591 : : return NULL;
592 : :
593 : : return state->connectors[index].state;
594 : : }
595 : :
596 : : /**
597 : : * drm_atomic_get_old_connector_state - get connector state, if it exists
598 : : * @state: global atomic state object
599 : : * @connector: connector to grab
600 : : *
601 : : * This function returns the old connector state for the given connector,
602 : : * or NULL if the connector is not part of the global atomic state.
603 : : */
604 : : static inline struct drm_connector_state *
605 : 0 : drm_atomic_get_old_connector_state(struct drm_atomic_state *state,
606 : : struct drm_connector *connector)
607 : : {
608 [ # # # # ]: 0 : int index = drm_connector_index(connector);
609 : :
610 [ # # # # ]: 0 : if (index >= state->num_connector)
611 : : return NULL;
612 : :
613 : 0 : return state->connectors[index].old_state;
614 : : }
615 : :
616 : : /**
617 : : * drm_atomic_get_new_connector_state - get connector state, if it exists
618 : : * @state: global atomic state object
619 : : * @connector: connector to grab
620 : : *
621 : : * This function returns the new connector state for the given connector,
622 : : * or NULL if the connector is not part of the global atomic state.
623 : : */
624 : : static inline struct drm_connector_state *
625 : 0 : drm_atomic_get_new_connector_state(struct drm_atomic_state *state,
626 : : struct drm_connector *connector)
627 : : {
628 [ # # # # ]: 0 : int index = drm_connector_index(connector);
629 : :
630 [ # # # # ]: 0 : if (index >= state->num_connector)
631 : : return NULL;
632 : :
633 [ # # ]: 0 : return state->connectors[index].new_state;
634 : : }
635 : :
636 : : /**
637 : : * __drm_atomic_get_current_plane_state - get current plane state
638 : : * @state: global atomic state object
639 : : * @plane: plane to grab
640 : : *
641 : : * This function returns the plane state for the given plane, either from
642 : : * @state, or if the plane isn't part of the atomic state update, from @plane.
643 : : * This is useful in atomic check callbacks, when drivers need to peek at, but
644 : : * not change, state of other planes, since it avoids threading an error code
645 : : * back up the call chain.
646 : : *
647 : : * WARNING:
648 : : *
649 : : * Note that this function is in general unsafe since it doesn't check for the
650 : : * required locking for access state structures. Drivers must ensure that it is
651 : : * safe to access the returned state structure through other means. One common
652 : : * example is when planes are fixed to a single CRTC, and the driver knows that
653 : : * the CRTC lock is held already. In that case holding the CRTC lock gives a
654 : : * read-lock on all planes connected to that CRTC. But if planes can be
655 : : * reassigned things get more tricky. In that case it's better to use
656 : : * drm_atomic_get_plane_state and wire up full error handling.
657 : : *
658 : : * Returns:
659 : : *
660 : : * Read-only pointer to the current plane state.
661 : : */
662 : : static inline const struct drm_plane_state *
663 : 0 : __drm_atomic_get_current_plane_state(struct drm_atomic_state *state,
664 : : struct drm_plane *plane)
665 : : {
666 [ # # # # : 0 : if (state->planes[drm_plane_index(plane)].state)
# # # # ]
667 : : return state->planes[drm_plane_index(plane)].state;
668 : :
669 : 0 : return plane->state;
670 : : }
671 : :
672 : : int __must_check
673 : : drm_atomic_add_affected_connectors(struct drm_atomic_state *state,
674 : : struct drm_crtc *crtc);
675 : : int __must_check
676 : : drm_atomic_add_affected_planes(struct drm_atomic_state *state,
677 : : struct drm_crtc *crtc);
678 : :
679 : : int __must_check drm_atomic_check_only(struct drm_atomic_state *state);
680 : : int __must_check drm_atomic_commit(struct drm_atomic_state *state);
681 : : int __must_check drm_atomic_nonblocking_commit(struct drm_atomic_state *state);
682 : :
683 : : void drm_state_dump(struct drm_device *dev, struct drm_printer *p);
684 : :
685 : : /**
686 : : * for_each_oldnew_connector_in_state - iterate over all connectors in an atomic update
687 : : * @__state: &struct drm_atomic_state pointer
688 : : * @connector: &struct drm_connector iteration cursor
689 : : * @old_connector_state: &struct drm_connector_state iteration cursor for the
690 : : * old state
691 : : * @new_connector_state: &struct drm_connector_state iteration cursor for the
692 : : * new state
693 : : * @__i: int iteration cursor, for macro-internal use
694 : : *
695 : : * This iterates over all connectors in an atomic update, tracking both old and
696 : : * new state. This is useful in places where the state delta needs to be
697 : : * considered, for example in atomic check functions.
698 : : */
699 : : #define for_each_oldnew_connector_in_state(__state, connector, old_connector_state, new_connector_state, __i) \
700 : : for ((__i) = 0; \
701 : : (__i) < (__state)->num_connector; \
702 : : (__i)++) \
703 : : for_each_if ((__state)->connectors[__i].ptr && \
704 : : ((connector) = (__state)->connectors[__i].ptr, \
705 : : (void)(connector) /* Only to avoid unused-but-set-variable warning */, \
706 : : (old_connector_state) = (__state)->connectors[__i].old_state, \
707 : : (new_connector_state) = (__state)->connectors[__i].new_state, 1))
708 : :
709 : : /**
710 : : * for_each_old_connector_in_state - iterate over all connectors in an atomic update
711 : : * @__state: &struct drm_atomic_state pointer
712 : : * @connector: &struct drm_connector iteration cursor
713 : : * @old_connector_state: &struct drm_connector_state iteration cursor for the
714 : : * old state
715 : : * @__i: int iteration cursor, for macro-internal use
716 : : *
717 : : * This iterates over all connectors in an atomic update, tracking only the old
718 : : * state. This is useful in disable functions, where we need the old state the
719 : : * hardware is still in.
720 : : */
721 : : #define for_each_old_connector_in_state(__state, connector, old_connector_state, __i) \
722 : : for ((__i) = 0; \
723 : : (__i) < (__state)->num_connector; \
724 : : (__i)++) \
725 : : for_each_if ((__state)->connectors[__i].ptr && \
726 : : ((connector) = (__state)->connectors[__i].ptr, \
727 : : (void)(connector) /* Only to avoid unused-but-set-variable warning */, \
728 : : (old_connector_state) = (__state)->connectors[__i].old_state, 1))
729 : :
730 : : /**
731 : : * for_each_new_connector_in_state - iterate over all connectors in an atomic update
732 : : * @__state: &struct drm_atomic_state pointer
733 : : * @connector: &struct drm_connector iteration cursor
734 : : * @new_connector_state: &struct drm_connector_state iteration cursor for the
735 : : * new state
736 : : * @__i: int iteration cursor, for macro-internal use
737 : : *
738 : : * This iterates over all connectors in an atomic update, tracking only the new
739 : : * state. This is useful in enable functions, where we need the new state the
740 : : * hardware should be in when the atomic commit operation has completed.
741 : : */
742 : : #define for_each_new_connector_in_state(__state, connector, new_connector_state, __i) \
743 : : for ((__i) = 0; \
744 : : (__i) < (__state)->num_connector; \
745 : : (__i)++) \
746 : : for_each_if ((__state)->connectors[__i].ptr && \
747 : : ((connector) = (__state)->connectors[__i].ptr, \
748 : : (void)(connector) /* Only to avoid unused-but-set-variable warning */, \
749 : : (new_connector_state) = (__state)->connectors[__i].new_state, \
750 : : (void)(new_connector_state) /* Only to avoid unused-but-set-variable warning */, 1))
751 : :
752 : : /**
753 : : * for_each_oldnew_crtc_in_state - iterate over all CRTCs in an atomic update
754 : : * @__state: &struct drm_atomic_state pointer
755 : : * @crtc: &struct drm_crtc iteration cursor
756 : : * @old_crtc_state: &struct drm_crtc_state iteration cursor for the old state
757 : : * @new_crtc_state: &struct drm_crtc_state iteration cursor for the new state
758 : : * @__i: int iteration cursor, for macro-internal use
759 : : *
760 : : * This iterates over all CRTCs in an atomic update, tracking both old and
761 : : * new state. This is useful in places where the state delta needs to be
762 : : * considered, for example in atomic check functions.
763 : : */
764 : : #define for_each_oldnew_crtc_in_state(__state, crtc, old_crtc_state, new_crtc_state, __i) \
765 : : for ((__i) = 0; \
766 : : (__i) < (__state)->dev->mode_config.num_crtc; \
767 : : (__i)++) \
768 : : for_each_if ((__state)->crtcs[__i].ptr && \
769 : : ((crtc) = (__state)->crtcs[__i].ptr, \
770 : : (void)(crtc) /* Only to avoid unused-but-set-variable warning */, \
771 : : (old_crtc_state) = (__state)->crtcs[__i].old_state, \
772 : : (void)(old_crtc_state) /* Only to avoid unused-but-set-variable warning */, \
773 : : (new_crtc_state) = (__state)->crtcs[__i].new_state, 1))
774 : :
775 : : /**
776 : : * for_each_old_crtc_in_state - iterate over all CRTCs in an atomic update
777 : : * @__state: &struct drm_atomic_state pointer
778 : : * @crtc: &struct drm_crtc iteration cursor
779 : : * @old_crtc_state: &struct drm_crtc_state iteration cursor for the old state
780 : : * @__i: int iteration cursor, for macro-internal use
781 : : *
782 : : * This iterates over all CRTCs in an atomic update, tracking only the old
783 : : * state. This is useful in disable functions, where we need the old state the
784 : : * hardware is still in.
785 : : */
786 : : #define for_each_old_crtc_in_state(__state, crtc, old_crtc_state, __i) \
787 : : for ((__i) = 0; \
788 : : (__i) < (__state)->dev->mode_config.num_crtc; \
789 : : (__i)++) \
790 : : for_each_if ((__state)->crtcs[__i].ptr && \
791 : : ((crtc) = (__state)->crtcs[__i].ptr, \
792 : : (old_crtc_state) = (__state)->crtcs[__i].old_state, 1))
793 : :
794 : : /**
795 : : * for_each_new_crtc_in_state - iterate over all CRTCs in an atomic update
796 : : * @__state: &struct drm_atomic_state pointer
797 : : * @crtc: &struct drm_crtc iteration cursor
798 : : * @new_crtc_state: &struct drm_crtc_state iteration cursor for the new state
799 : : * @__i: int iteration cursor, for macro-internal use
800 : : *
801 : : * This iterates over all CRTCs in an atomic update, tracking only the new
802 : : * state. This is useful in enable functions, where we need the new state the
803 : : * hardware should be in when the atomic commit operation has completed.
804 : : */
805 : : #define for_each_new_crtc_in_state(__state, crtc, new_crtc_state, __i) \
806 : : for ((__i) = 0; \
807 : : (__i) < (__state)->dev->mode_config.num_crtc; \
808 : : (__i)++) \
809 : : for_each_if ((__state)->crtcs[__i].ptr && \
810 : : ((crtc) = (__state)->crtcs[__i].ptr, \
811 : : (void)(crtc) /* Only to avoid unused-but-set-variable warning */, \
812 : : (new_crtc_state) = (__state)->crtcs[__i].new_state, \
813 : : (void)(new_crtc_state) /* Only to avoid unused-but-set-variable warning */, 1))
814 : :
815 : : /**
816 : : * for_each_oldnew_plane_in_state - iterate over all planes in an atomic update
817 : : * @__state: &struct drm_atomic_state pointer
818 : : * @plane: &struct drm_plane iteration cursor
819 : : * @old_plane_state: &struct drm_plane_state iteration cursor for the old state
820 : : * @new_plane_state: &struct drm_plane_state iteration cursor for the new state
821 : : * @__i: int iteration cursor, for macro-internal use
822 : : *
823 : : * This iterates over all planes in an atomic update, tracking both old and
824 : : * new state. This is useful in places where the state delta needs to be
825 : : * considered, for example in atomic check functions.
826 : : */
827 : : #define for_each_oldnew_plane_in_state(__state, plane, old_plane_state, new_plane_state, __i) \
828 : : for ((__i) = 0; \
829 : : (__i) < (__state)->dev->mode_config.num_total_plane; \
830 : : (__i)++) \
831 : : for_each_if ((__state)->planes[__i].ptr && \
832 : : ((plane) = (__state)->planes[__i].ptr, \
833 : : (void)(plane) /* Only to avoid unused-but-set-variable warning */, \
834 : : (old_plane_state) = (__state)->planes[__i].old_state,\
835 : : (new_plane_state) = (__state)->planes[__i].new_state, 1))
836 : :
837 : : /**
838 : : * for_each_oldnew_plane_in_state_reverse - iterate over all planes in an atomic
839 : : * update in reverse order
840 : : * @__state: &struct drm_atomic_state pointer
841 : : * @plane: &struct drm_plane iteration cursor
842 : : * @old_plane_state: &struct drm_plane_state iteration cursor for the old state
843 : : * @new_plane_state: &struct drm_plane_state iteration cursor for the new state
844 : : * @__i: int iteration cursor, for macro-internal use
845 : : *
846 : : * This iterates over all planes in an atomic update in reverse order,
847 : : * tracking both old and new state. This is useful in places where the
848 : : * state delta needs to be considered, for example in atomic check functions.
849 : : */
850 : : #define for_each_oldnew_plane_in_state_reverse(__state, plane, old_plane_state, new_plane_state, __i) \
851 : : for ((__i) = ((__state)->dev->mode_config.num_total_plane - 1); \
852 : : (__i) >= 0; \
853 : : (__i)--) \
854 : : for_each_if ((__state)->planes[__i].ptr && \
855 : : ((plane) = (__state)->planes[__i].ptr, \
856 : : (old_plane_state) = (__state)->planes[__i].old_state,\
857 : : (new_plane_state) = (__state)->planes[__i].new_state, 1))
858 : :
859 : : /**
860 : : * for_each_old_plane_in_state - iterate over all planes in an atomic update
861 : : * @__state: &struct drm_atomic_state pointer
862 : : * @plane: &struct drm_plane iteration cursor
863 : : * @old_plane_state: &struct drm_plane_state iteration cursor for the old state
864 : : * @__i: int iteration cursor, for macro-internal use
865 : : *
866 : : * This iterates over all planes in an atomic update, tracking only the old
867 : : * state. This is useful in disable functions, where we need the old state the
868 : : * hardware is still in.
869 : : */
870 : : #define for_each_old_plane_in_state(__state, plane, old_plane_state, __i) \
871 : : for ((__i) = 0; \
872 : : (__i) < (__state)->dev->mode_config.num_total_plane; \
873 : : (__i)++) \
874 : : for_each_if ((__state)->planes[__i].ptr && \
875 : : ((plane) = (__state)->planes[__i].ptr, \
876 : : (old_plane_state) = (__state)->planes[__i].old_state, 1))
877 : : /**
878 : : * for_each_new_plane_in_state - iterate over all planes in an atomic update
879 : : * @__state: &struct drm_atomic_state pointer
880 : : * @plane: &struct drm_plane iteration cursor
881 : : * @new_plane_state: &struct drm_plane_state iteration cursor for the new state
882 : : * @__i: int iteration cursor, for macro-internal use
883 : : *
884 : : * This iterates over all planes in an atomic update, tracking only the new
885 : : * state. This is useful in enable functions, where we need the new state the
886 : : * hardware should be in when the atomic commit operation has completed.
887 : : */
888 : : #define for_each_new_plane_in_state(__state, plane, new_plane_state, __i) \
889 : : for ((__i) = 0; \
890 : : (__i) < (__state)->dev->mode_config.num_total_plane; \
891 : : (__i)++) \
892 : : for_each_if ((__state)->planes[__i].ptr && \
893 : : ((plane) = (__state)->planes[__i].ptr, \
894 : : (void)(plane) /* Only to avoid unused-but-set-variable warning */, \
895 : : (new_plane_state) = (__state)->planes[__i].new_state, \
896 : : (void)(new_plane_state) /* Only to avoid unused-but-set-variable warning */, 1))
897 : :
898 : : /**
899 : : * for_each_oldnew_private_obj_in_state - iterate over all private objects in an atomic update
900 : : * @__state: &struct drm_atomic_state pointer
901 : : * @obj: &struct drm_private_obj iteration cursor
902 : : * @old_obj_state: &struct drm_private_state iteration cursor for the old state
903 : : * @new_obj_state: &struct drm_private_state iteration cursor for the new state
904 : : * @__i: int iteration cursor, for macro-internal use
905 : : *
906 : : * This iterates over all private objects in an atomic update, tracking both
907 : : * old and new state. This is useful in places where the state delta needs
908 : : * to be considered, for example in atomic check functions.
909 : : */
910 : : #define for_each_oldnew_private_obj_in_state(__state, obj, old_obj_state, new_obj_state, __i) \
911 : : for ((__i) = 0; \
912 : : (__i) < (__state)->num_private_objs && \
913 : : ((obj) = (__state)->private_objs[__i].ptr, \
914 : : (old_obj_state) = (__state)->private_objs[__i].old_state, \
915 : : (new_obj_state) = (__state)->private_objs[__i].new_state, 1); \
916 : : (__i)++)
917 : :
918 : : /**
919 : : * for_each_old_private_obj_in_state - iterate over all private objects in an atomic update
920 : : * @__state: &struct drm_atomic_state pointer
921 : : * @obj: &struct drm_private_obj iteration cursor
922 : : * @old_obj_state: &struct drm_private_state iteration cursor for the old state
923 : : * @__i: int iteration cursor, for macro-internal use
924 : : *
925 : : * This iterates over all private objects in an atomic update, tracking only
926 : : * the old state. This is useful in disable functions, where we need the old
927 : : * state the hardware is still in.
928 : : */
929 : : #define for_each_old_private_obj_in_state(__state, obj, old_obj_state, __i) \
930 : : for ((__i) = 0; \
931 : : (__i) < (__state)->num_private_objs && \
932 : : ((obj) = (__state)->private_objs[__i].ptr, \
933 : : (old_obj_state) = (__state)->private_objs[__i].old_state, 1); \
934 : : (__i)++)
935 : :
936 : : /**
937 : : * for_each_new_private_obj_in_state - iterate over all private objects in an atomic update
938 : : * @__state: &struct drm_atomic_state pointer
939 : : * @obj: &struct drm_private_obj iteration cursor
940 : : * @new_obj_state: &struct drm_private_state iteration cursor for the new state
941 : : * @__i: int iteration cursor, for macro-internal use
942 : : *
943 : : * This iterates over all private objects in an atomic update, tracking only
944 : : * the new state. This is useful in enable functions, where we need the new state the
945 : : * hardware should be in when the atomic commit operation has completed.
946 : : */
947 : : #define for_each_new_private_obj_in_state(__state, obj, new_obj_state, __i) \
948 : : for ((__i) = 0; \
949 : : (__i) < (__state)->num_private_objs && \
950 : : ((obj) = (__state)->private_objs[__i].ptr, \
951 : : (new_obj_state) = (__state)->private_objs[__i].new_state, 1); \
952 : : (__i)++)
953 : :
954 : : /**
955 : : * drm_atomic_crtc_needs_modeset - compute combined modeset need
956 : : * @state: &drm_crtc_state for the CRTC
957 : : *
958 : : * To give drivers flexibility &struct drm_crtc_state has 3 booleans to track
959 : : * whether the state CRTC changed enough to need a full modeset cycle:
960 : : * mode_changed, active_changed and connectors_changed. This helper simply
961 : : * combines these three to compute the overall need for a modeset for @state.
962 : : *
963 : : * The atomic helper code sets these booleans, but drivers can and should
964 : : * change them appropriately to accurately represent whether a modeset is
965 : : * really needed. In general, drivers should avoid full modesets whenever
966 : : * possible.
967 : : *
968 : : * For example if the CRTC mode has changed, and the hardware is able to enact
969 : : * the requested mode change without going through a full modeset, the driver
970 : : * should clear mode_changed in its &drm_mode_config_funcs.atomic_check
971 : : * implementation.
972 : : */
973 : : static inline bool
974 : 0 : drm_atomic_crtc_needs_modeset(const struct drm_crtc_state *state)
975 : : {
976 [ # # # # : 0 : return state->mode_changed || state->active_changed ||
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # ]
977 : : state->connectors_changed;
978 : : }
979 : :
980 : : /**
981 : : * drm_atomic_crtc_effectively_active - compute whether CRTC is actually active
982 : : * @state: &drm_crtc_state for the CRTC
983 : : *
984 : : * When in self refresh mode, the crtc_state->active value will be false, since
985 : : * the CRTC is off. However in some cases we're interested in whether the CRTC
986 : : * is active, or effectively active (ie: it's connected to an active display).
987 : : * In these cases, use this function instead of just checking active.
988 : : */
989 : : static inline bool
990 : 0 : drm_atomic_crtc_effectively_active(const struct drm_crtc_state *state)
991 : : {
992 [ # # # # ]: 0 : return state->active || state->self_refresh_active;
993 : : }
994 : :
995 : : #endif /* DRM_ATOMIC_H_ */
|
