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 | * See also drm_crtc_commit_wait(). |
71 | */ |
72 | struct drm_crtc_commit { |
73 | /** |
74 | * @crtc: |
75 | * |
76 | * DRM CRTC for this commit. |
77 | */ |
78 | struct drm_crtc *crtc; |
79 | |
80 | /** |
81 | * @ref: |
82 | * |
83 | * Reference count for this structure. Needed to allow blocking on |
84 | * completions without the risk of the completion disappearing |
85 | * meanwhile. |
86 | */ |
87 | struct kref ref; |
88 | |
89 | /** |
90 | * @flip_done: |
91 | * |
92 | * Will be signaled when the hardware has flipped to the new set of |
93 | * buffers. Signals at the same time as when the drm event for this |
94 | * commit is sent to userspace, or when an out-fence is singalled. Note |
95 | * that for most hardware, in most cases this happens after @hw_done is |
96 | * signalled. |
97 | * |
98 | * Completion of this stage is signalled implicitly by calling |
99 | * drm_crtc_send_vblank_event() on &drm_crtc_state.event. |
100 | */ |
101 | struct completion flip_done; |
102 | |
103 | /** |
104 | * @hw_done: |
105 | * |
106 | * Will be signalled when all hw register changes for this commit have |
107 | * been written out. Especially when disabling a pipe this can be much |
108 | * later than @flip_done, since that can signal already when the |
109 | * screen goes black, whereas to fully shut down a pipe more register |
110 | * I/O is required. |
111 | * |
112 | * Note that this does not need to include separately reference-counted |
113 | * resources like backing storage buffer pinning, or runtime pm |
114 | * management. |
115 | * |
116 | * Drivers should call drm_atomic_helper_commit_hw_done() to signal |
117 | * completion of this stage. |
118 | */ |
119 | struct completion hw_done; |
120 | |
121 | /** |
122 | * @cleanup_done: |
123 | * |
124 | * Will be signalled after old buffers have been cleaned up by calling |
125 | * drm_atomic_helper_cleanup_planes(). Since this can only happen after |
126 | * a vblank wait completed it might be a bit later. This completion is |
127 | * useful to throttle updates and avoid hardware updates getting ahead |
128 | * of the buffer cleanup too much. |
129 | * |
130 | * Drivers should call drm_atomic_helper_commit_cleanup_done() to signal |
131 | * completion of this stage. |
132 | */ |
133 | struct completion cleanup_done; |
134 | |
135 | /** |
136 | * @commit_entry: |
137 | * |
138 | * Entry on the per-CRTC &drm_crtc.commit_list. Protected by |
139 | * $drm_crtc.commit_lock. |
140 | */ |
141 | struct list_head commit_entry; |
142 | |
143 | /** |
144 | * @event: |
145 | * |
146 | * &drm_pending_vblank_event pointer to clean up private events. |
147 | */ |
148 | struct drm_pending_vblank_event *event; |
149 | |
150 | /** |
151 | * @abort_completion: |
152 | * |
153 | * A flag that's set after drm_atomic_helper_setup_commit() takes a |
154 | * second reference for the completion of $drm_crtc_state.event. It's |
155 | * used by the free code to remove the second reference if commit fails. |
156 | */ |
157 | bool abort_completion; |
158 | }; |
159 | |
160 | struct __drm_planes_state { |
161 | struct drm_plane *ptr; |
162 | struct drm_plane_state *state, *old_state, *new_state; |
163 | }; |
164 | |
165 | struct __drm_crtcs_state { |
166 | struct drm_crtc *ptr; |
167 | struct drm_crtc_state *state, *old_state, *new_state; |
168 | |
169 | /** |
170 | * @commit: |
171 | * |
172 | * A reference to the CRTC commit object that is kept for use by |
173 | * drm_atomic_helper_wait_for_flip_done() after |
174 | * drm_atomic_helper_commit_hw_done() is called. This ensures that a |
175 | * concurrent commit won't free a commit object that is still in use. |
176 | */ |
177 | struct drm_crtc_commit *commit; |
178 | |
179 | s32 __user *out_fence_ptr; |
180 | u64 last_vblank_count; |
181 | }; |
182 | |
183 | struct __drm_connnectors_state { |
184 | struct drm_connector *ptr; |
185 | struct drm_connector_state *state, *old_state, *new_state; |
186 | /** |
187 | * @out_fence_ptr: |
188 | * |
189 | * User-provided pointer which the kernel uses to return a sync_file |
190 | * file descriptor. Used by writeback connectors to signal completion of |
191 | * the writeback. |
192 | */ |
193 | s32 __user *out_fence_ptr; |
194 | }; |
195 | |
196 | struct drm_private_obj; |
197 | struct drm_private_state; |
198 | |
199 | /** |
200 | * struct drm_private_state_funcs - atomic state functions for private objects |
201 | * |
202 | * These hooks are used by atomic helpers to create, swap and destroy states of |
203 | * private objects. The structure itself is used as a vtable to identify the |
204 | * associated private object type. Each private object type that needs to be |
205 | * added to the atomic states is expected to have an implementation of these |
206 | * hooks and pass a pointer to its drm_private_state_funcs struct to |
207 | * drm_atomic_get_private_obj_state(). |
208 | */ |
209 | struct drm_private_state_funcs { |
210 | /** |
211 | * @atomic_duplicate_state: |
212 | * |
213 | * Duplicate the current state of the private object and return it. It |
214 | * is an error to call this before obj->state has been initialized. |
215 | * |
216 | * RETURNS: |
217 | * |
218 | * Duplicated atomic state or NULL when obj->state is not |
219 | * initialized or allocation failed. |
220 | */ |
221 | struct drm_private_state *(*atomic_duplicate_state)(struct drm_private_obj *obj); |
222 | |
223 | /** |
224 | * @atomic_destroy_state: |
225 | * |
226 | * Frees the private object state created with @atomic_duplicate_state. |
227 | */ |
228 | void (*atomic_destroy_state)(struct drm_private_obj *obj, |
229 | struct drm_private_state *state); |
230 | |
231 | /** |
232 | * @atomic_print_state: |
233 | * |
234 | * If driver subclasses &struct drm_private_state, it should implement |
235 | * this optional hook for printing additional driver specific state. |
236 | * |
237 | * Do not call this directly, use drm_atomic_private_obj_print_state() |
238 | * instead. |
239 | */ |
240 | void (*atomic_print_state)(struct drm_printer *p, |
241 | const struct drm_private_state *state); |
242 | }; |
243 | |
244 | /** |
245 | * struct drm_private_obj - base struct for driver private atomic object |
246 | * |
247 | * A driver private object is initialized by calling |
248 | * drm_atomic_private_obj_init() and cleaned up by calling |
249 | * drm_atomic_private_obj_fini(). |
250 | * |
251 | * Currently only tracks the state update functions and the opaque driver |
252 | * private state itself, but in the future might also track which |
253 | * &drm_modeset_lock is required to duplicate and update this object's state. |
254 | * |
255 | * All private objects must be initialized before the DRM device they are |
256 | * attached to is registered to the DRM subsystem (call to drm_dev_register()) |
257 | * and should stay around until this DRM device is unregistered (call to |
258 | * drm_dev_unregister()). In other words, private objects lifetime is tied |
259 | * to the DRM device lifetime. This implies that: |
260 | * |
261 | * 1/ all calls to drm_atomic_private_obj_init() must be done before calling |
262 | * drm_dev_register() |
263 | * 2/ all calls to drm_atomic_private_obj_fini() must be done after calling |
264 | * drm_dev_unregister() |
265 | * |
266 | * If that private object is used to store a state shared by multiple |
267 | * CRTCs, proper care must be taken to ensure that non-blocking commits are |
268 | * properly ordered to avoid a use-after-free issue. |
269 | * |
270 | * Indeed, assuming a sequence of two non-blocking &drm_atomic_commit on two |
271 | * different &drm_crtc using different &drm_plane and &drm_connector, so with no |
272 | * resources shared, there's no guarantee on which commit is going to happen |
273 | * first. However, the second &drm_atomic_commit will consider the first |
274 | * &drm_private_obj its old state, and will be in charge of freeing it whenever |
275 | * the second &drm_atomic_commit is done. |
276 | * |
277 | * If the first &drm_atomic_commit happens after it, it will consider its |
278 | * &drm_private_obj the new state and will be likely to access it, resulting in |
279 | * an access to a freed memory region. Drivers should store (and get a reference |
280 | * to) the &drm_crtc_commit structure in our private state in |
281 | * &drm_mode_config_helper_funcs.atomic_commit_setup, and then wait for that |
282 | * commit to complete as the first step of |
283 | * &drm_mode_config_helper_funcs.atomic_commit_tail, similar to |
284 | * drm_atomic_helper_wait_for_dependencies(). |
285 | */ |
286 | struct drm_private_obj { |
287 | /** |
288 | * @head: List entry used to attach a private object to a &drm_device |
289 | * (queued to &drm_mode_config.privobj_list). |
290 | */ |
291 | struct list_head head; |
292 | |
293 | /** |
294 | * @lock: Modeset lock to protect the state object. |
295 | */ |
296 | struct drm_modeset_lock lock; |
297 | |
298 | /** |
299 | * @state: Current atomic state for this driver private object. |
300 | */ |
301 | struct drm_private_state *state; |
302 | |
303 | /** |
304 | * @funcs: |
305 | * |
306 | * Functions to manipulate the state of this driver private object, see |
307 | * &drm_private_state_funcs. |
308 | */ |
309 | const struct drm_private_state_funcs *funcs; |
310 | }; |
311 | |
312 | /** |
313 | * drm_for_each_privobj() - private object iterator |
314 | * |
315 | * @privobj: pointer to the current private object. Updated after each |
316 | * iteration |
317 | * @dev: the DRM device we want get private objects from |
318 | * |
319 | * Allows one to iterate over all private objects attached to @dev |
320 | */ |
321 | #define drm_for_each_privobj(privobj, dev) \ |
322 | list_for_each_entry(privobj, &(dev)->mode_config.privobj_list, head) |
323 | |
324 | /** |
325 | * struct drm_private_state - base struct for driver private object state |
326 | * |
327 | * Currently only contains a backpointer to the overall atomic update, |
328 | * and the relevant private object but in the future also might hold |
329 | * synchronization information similar to e.g. &drm_crtc.commit. |
330 | */ |
331 | struct drm_private_state { |
332 | /** |
333 | * @state: backpointer to global drm_atomic_state |
334 | */ |
335 | struct drm_atomic_state *state; |
336 | |
337 | /** |
338 | * @obj: backpointer to the private object |
339 | */ |
340 | struct drm_private_obj *obj; |
341 | }; |
342 | |
343 | struct __drm_private_objs_state { |
344 | struct drm_private_obj *ptr; |
345 | struct drm_private_state *state, *old_state, *new_state; |
346 | }; |
347 | |
348 | /** |
349 | * struct drm_atomic_state - Atomic commit structure |
350 | * |
351 | * This structure is the kernel counterpart of @drm_mode_atomic and represents |
352 | * an atomic commit that transitions from an old to a new display state. It |
353 | * contains all the objects affected by the atomic commit and both the new |
354 | * state structures and pointers to the old state structures for |
355 | * these. |
356 | * |
357 | * States are added to an atomic update by calling drm_atomic_get_crtc_state(), |
358 | * drm_atomic_get_plane_state(), drm_atomic_get_connector_state(), or for |
359 | * private state structures, drm_atomic_get_private_obj_state(). |
360 | */ |
361 | struct drm_atomic_state { |
362 | /** |
363 | * @ref: |
364 | * |
365 | * Count of all references to this update (will not be freed until zero). |
366 | */ |
367 | struct kref ref; |
368 | |
369 | /** |
370 | * @dev: Parent DRM Device. |
371 | */ |
372 | struct drm_device *dev; |
373 | |
374 | /** |
375 | * @allow_modeset: |
376 | * |
377 | * Allow full modeset. This is used by the ATOMIC IOCTL handler to |
378 | * implement the DRM_MODE_ATOMIC_ALLOW_MODESET flag. Drivers should |
379 | * never consult this flag, instead looking at the output of |
380 | * drm_atomic_crtc_needs_modeset(). |
381 | */ |
382 | bool allow_modeset : 1; |
383 | /** |
384 | * @legacy_cursor_update: |
385 | * |
386 | * Hint to enforce legacy cursor IOCTL semantics. |
387 | * |
388 | * WARNING: This is thoroughly broken and pretty much impossible to |
389 | * implement correctly. Drivers must ignore this and should instead |
390 | * implement &drm_plane_helper_funcs.atomic_async_check and |
391 | * &drm_plane_helper_funcs.atomic_async_commit hooks. New users of this |
392 | * flag are not allowed. |
393 | */ |
394 | bool legacy_cursor_update : 1; |
395 | |
396 | /** |
397 | * @async_update: hint for asynchronous plane update |
398 | */ |
399 | bool async_update : 1; |
400 | |
401 | /** |
402 | * @duplicated: |
403 | * |
404 | * Indicates whether or not this atomic state was duplicated using |
405 | * drm_atomic_helper_duplicate_state(). Drivers and atomic helpers |
406 | * should use this to fixup normal inconsistencies in duplicated |
407 | * states. |
408 | */ |
409 | bool duplicated : 1; |
410 | |
411 | /** |
412 | * @planes: |
413 | * |
414 | * Pointer to array of @drm_plane and @drm_plane_state part of this |
415 | * update. |
416 | */ |
417 | struct __drm_planes_state *planes; |
418 | |
419 | /** |
420 | * @crtcs: |
421 | * |
422 | * Pointer to array of @drm_crtc and @drm_crtc_state part of this |
423 | * update. |
424 | */ |
425 | struct __drm_crtcs_state *crtcs; |
426 | |
427 | /** |
428 | * @num_connector: size of the @connectors array |
429 | */ |
430 | int num_connector; |
431 | |
432 | /** |
433 | * @connectors: |
434 | * |
435 | * Pointer to array of @drm_connector and @drm_connector_state part of |
436 | * this update. |
437 | */ |
438 | struct __drm_connnectors_state *connectors; |
439 | |
440 | /** |
441 | * @num_private_objs: size of the @private_objs array |
442 | */ |
443 | int num_private_objs; |
444 | |
445 | /** |
446 | * @private_objs: |
447 | * |
448 | * Pointer to array of @drm_private_obj and @drm_private_obj_state part |
449 | * of this update. |
450 | */ |
451 | struct __drm_private_objs_state *private_objs; |
452 | |
453 | /** |
454 | * @acquire_ctx: acquire context for this atomic modeset state update |
455 | */ |
456 | struct drm_modeset_acquire_ctx *acquire_ctx; |
457 | |
458 | /** |
459 | * @fake_commit: |
460 | * |
461 | * Used for signaling unbound planes/connectors. |
462 | * When a connector or plane is not bound to any CRTC, it's still important |
463 | * to preserve linearity to prevent the atomic states from being freed to early. |
464 | * |
465 | * This commit (if set) is not bound to any CRTC, but will be completed when |
466 | * drm_atomic_helper_commit_hw_done() is called. |
467 | */ |
468 | struct drm_crtc_commit *fake_commit; |
469 | |
470 | /** |
471 | * @commit_work: |
472 | * |
473 | * Work item which can be used by the driver or helpers to execute the |
474 | * commit without blocking. |
475 | */ |
476 | struct work_struct commit_work; |
477 | }; |
478 | |
479 | void __drm_crtc_commit_free(struct kref *kref); |
480 | |
481 | /** |
482 | * drm_crtc_commit_get - acquire a reference to the CRTC commit |
483 | * @commit: CRTC commit |
484 | * |
485 | * Increases the reference of @commit. |
486 | * |
487 | * Returns: |
488 | * The pointer to @commit, with reference increased. |
489 | */ |
490 | static inline struct drm_crtc_commit *drm_crtc_commit_get(struct drm_crtc_commit *commit) |
491 | { |
492 | kref_get(kref: &commit->ref); |
493 | return commit; |
494 | } |
495 | |
496 | /** |
497 | * drm_crtc_commit_put - release a reference to the CRTC commmit |
498 | * @commit: CRTC commit |
499 | * |
500 | * This releases a reference to @commit which is freed after removing the |
501 | * final reference. No locking required and callable from any context. |
502 | */ |
503 | static inline void drm_crtc_commit_put(struct drm_crtc_commit *commit) |
504 | { |
505 | kref_put(kref: &commit->ref, release: __drm_crtc_commit_free); |
506 | } |
507 | |
508 | int drm_crtc_commit_wait(struct drm_crtc_commit *commit); |
509 | |
510 | struct drm_atomic_state * __must_check |
511 | drm_atomic_state_alloc(struct drm_device *dev); |
512 | void drm_atomic_state_clear(struct drm_atomic_state *state); |
513 | |
514 | /** |
515 | * drm_atomic_state_get - acquire a reference to the atomic state |
516 | * @state: The atomic state |
517 | * |
518 | * Returns a new reference to the @state |
519 | */ |
520 | static inline struct drm_atomic_state * |
521 | drm_atomic_state_get(struct drm_atomic_state *state) |
522 | { |
523 | kref_get(kref: &state->ref); |
524 | return state; |
525 | } |
526 | |
527 | void __drm_atomic_state_free(struct kref *ref); |
528 | |
529 | /** |
530 | * drm_atomic_state_put - release a reference to the atomic state |
531 | * @state: The atomic state |
532 | * |
533 | * This releases a reference to @state which is freed after removing the |
534 | * final reference. No locking required and callable from any context. |
535 | */ |
536 | static inline void drm_atomic_state_put(struct drm_atomic_state *state) |
537 | { |
538 | kref_put(kref: &state->ref, release: __drm_atomic_state_free); |
539 | } |
540 | |
541 | int __must_check |
542 | drm_atomic_state_init(struct drm_device *dev, struct drm_atomic_state *state); |
543 | void drm_atomic_state_default_clear(struct drm_atomic_state *state); |
544 | void drm_atomic_state_default_release(struct drm_atomic_state *state); |
545 | |
546 | struct drm_crtc_state * __must_check |
547 | drm_atomic_get_crtc_state(struct drm_atomic_state *state, |
548 | struct drm_crtc *crtc); |
549 | struct drm_plane_state * __must_check |
550 | drm_atomic_get_plane_state(struct drm_atomic_state *state, |
551 | struct drm_plane *plane); |
552 | struct drm_connector_state * __must_check |
553 | drm_atomic_get_connector_state(struct drm_atomic_state *state, |
554 | struct drm_connector *connector); |
555 | |
556 | void drm_atomic_private_obj_init(struct drm_device *dev, |
557 | struct drm_private_obj *obj, |
558 | struct drm_private_state *state, |
559 | const struct drm_private_state_funcs *funcs); |
560 | void drm_atomic_private_obj_fini(struct drm_private_obj *obj); |
561 | |
562 | struct drm_private_state * __must_check |
563 | drm_atomic_get_private_obj_state(struct drm_atomic_state *state, |
564 | struct drm_private_obj *obj); |
565 | struct drm_private_state * |
566 | drm_atomic_get_old_private_obj_state(const struct drm_atomic_state *state, |
567 | struct drm_private_obj *obj); |
568 | struct drm_private_state * |
569 | drm_atomic_get_new_private_obj_state(const struct drm_atomic_state *state, |
570 | struct drm_private_obj *obj); |
571 | |
572 | struct drm_connector * |
573 | drm_atomic_get_old_connector_for_encoder(const struct drm_atomic_state *state, |
574 | struct drm_encoder *encoder); |
575 | struct drm_connector * |
576 | drm_atomic_get_new_connector_for_encoder(const struct drm_atomic_state *state, |
577 | struct drm_encoder *encoder); |
578 | |
579 | struct drm_crtc * |
580 | drm_atomic_get_old_crtc_for_encoder(struct drm_atomic_state *state, |
581 | struct drm_encoder *encoder); |
582 | struct drm_crtc * |
583 | drm_atomic_get_new_crtc_for_encoder(struct drm_atomic_state *state, |
584 | struct drm_encoder *encoder); |
585 | |
586 | /** |
587 | * drm_atomic_get_existing_crtc_state - get CRTC state, if it exists |
588 | * @state: global atomic state object |
589 | * @crtc: CRTC to grab |
590 | * |
591 | * This function returns the CRTC state for the given CRTC, or NULL |
592 | * if the CRTC is not part of the global atomic state. |
593 | * |
594 | * This function is deprecated, @drm_atomic_get_old_crtc_state or |
595 | * @drm_atomic_get_new_crtc_state should be used instead. |
596 | */ |
597 | static inline struct drm_crtc_state * |
598 | drm_atomic_get_existing_crtc_state(const struct drm_atomic_state *state, |
599 | struct drm_crtc *crtc) |
600 | { |
601 | return state->crtcs[drm_crtc_index(crtc)].state; |
602 | } |
603 | |
604 | /** |
605 | * drm_atomic_get_old_crtc_state - get old CRTC state, if it exists |
606 | * @state: global atomic state object |
607 | * @crtc: CRTC to grab |
608 | * |
609 | * This function returns the old CRTC state for the given CRTC, or |
610 | * NULL if the CRTC is not part of the global atomic state. |
611 | */ |
612 | static inline struct drm_crtc_state * |
613 | drm_atomic_get_old_crtc_state(const struct drm_atomic_state *state, |
614 | struct drm_crtc *crtc) |
615 | { |
616 | return state->crtcs[drm_crtc_index(crtc)].old_state; |
617 | } |
618 | /** |
619 | * drm_atomic_get_new_crtc_state - get new CRTC state, if it exists |
620 | * @state: global atomic state object |
621 | * @crtc: CRTC to grab |
622 | * |
623 | * This function returns the new CRTC state for the given CRTC, or |
624 | * NULL if the CRTC is not part of the global atomic state. |
625 | */ |
626 | static inline struct drm_crtc_state * |
627 | drm_atomic_get_new_crtc_state(const struct drm_atomic_state *state, |
628 | struct drm_crtc *crtc) |
629 | { |
630 | return state->crtcs[drm_crtc_index(crtc)].new_state; |
631 | } |
632 | |
633 | /** |
634 | * drm_atomic_get_existing_plane_state - get plane state, if it exists |
635 | * @state: global atomic state object |
636 | * @plane: plane to grab |
637 | * |
638 | * This function returns the plane state for the given plane, or NULL |
639 | * if the plane is not part of the global atomic state. |
640 | * |
641 | * This function is deprecated, @drm_atomic_get_old_plane_state or |
642 | * @drm_atomic_get_new_plane_state should be used instead. |
643 | */ |
644 | static inline struct drm_plane_state * |
645 | drm_atomic_get_existing_plane_state(const struct drm_atomic_state *state, |
646 | struct drm_plane *plane) |
647 | { |
648 | return state->planes[drm_plane_index(plane)].state; |
649 | } |
650 | |
651 | /** |
652 | * drm_atomic_get_old_plane_state - get plane state, if it exists |
653 | * @state: global atomic state object |
654 | * @plane: plane to grab |
655 | * |
656 | * This function returns the old plane state for the given plane, or |
657 | * NULL if the plane is not part of the global atomic state. |
658 | */ |
659 | static inline struct drm_plane_state * |
660 | drm_atomic_get_old_plane_state(const struct drm_atomic_state *state, |
661 | struct drm_plane *plane) |
662 | { |
663 | return state->planes[drm_plane_index(plane)].old_state; |
664 | } |
665 | |
666 | /** |
667 | * drm_atomic_get_new_plane_state - get plane state, if it exists |
668 | * @state: global atomic state object |
669 | * @plane: plane to grab |
670 | * |
671 | * This function returns the new plane state for the given plane, or |
672 | * NULL if the plane is not part of the global atomic state. |
673 | */ |
674 | static inline struct drm_plane_state * |
675 | drm_atomic_get_new_plane_state(const struct drm_atomic_state *state, |
676 | struct drm_plane *plane) |
677 | { |
678 | return state->planes[drm_plane_index(plane)].new_state; |
679 | } |
680 | |
681 | /** |
682 | * drm_atomic_get_existing_connector_state - get connector state, if it exists |
683 | * @state: global atomic state object |
684 | * @connector: connector to grab |
685 | * |
686 | * This function returns the connector state for the given connector, |
687 | * or NULL if the connector is not part of the global atomic state. |
688 | * |
689 | * This function is deprecated, @drm_atomic_get_old_connector_state or |
690 | * @drm_atomic_get_new_connector_state should be used instead. |
691 | */ |
692 | static inline struct drm_connector_state * |
693 | drm_atomic_get_existing_connector_state(const struct drm_atomic_state *state, |
694 | struct drm_connector *connector) |
695 | { |
696 | int index = drm_connector_index(connector); |
697 | |
698 | if (index >= state->num_connector) |
699 | return NULL; |
700 | |
701 | return state->connectors[index].state; |
702 | } |
703 | |
704 | /** |
705 | * drm_atomic_get_old_connector_state - get connector state, if it exists |
706 | * @state: global atomic state object |
707 | * @connector: connector to grab |
708 | * |
709 | * This function returns the old connector state for the given connector, |
710 | * or NULL if the connector is not part of the global atomic state. |
711 | */ |
712 | static inline struct drm_connector_state * |
713 | drm_atomic_get_old_connector_state(const struct drm_atomic_state *state, |
714 | struct drm_connector *connector) |
715 | { |
716 | int index = drm_connector_index(connector); |
717 | |
718 | if (index >= state->num_connector) |
719 | return NULL; |
720 | |
721 | return state->connectors[index].old_state; |
722 | } |
723 | |
724 | /** |
725 | * drm_atomic_get_new_connector_state - get connector state, if it exists |
726 | * @state: global atomic state object |
727 | * @connector: connector to grab |
728 | * |
729 | * This function returns the new connector state for the given connector, |
730 | * or NULL if the connector is not part of the global atomic state. |
731 | */ |
732 | static inline struct drm_connector_state * |
733 | drm_atomic_get_new_connector_state(const struct drm_atomic_state *state, |
734 | struct drm_connector *connector) |
735 | { |
736 | int index = drm_connector_index(connector); |
737 | |
738 | if (index >= state->num_connector) |
739 | return NULL; |
740 | |
741 | return state->connectors[index].new_state; |
742 | } |
743 | |
744 | /** |
745 | * __drm_atomic_get_current_plane_state - get current plane state |
746 | * @state: global atomic state object |
747 | * @plane: plane to grab |
748 | * |
749 | * This function returns the plane state for the given plane, either from |
750 | * @state, or if the plane isn't part of the atomic state update, from @plane. |
751 | * This is useful in atomic check callbacks, when drivers need to peek at, but |
752 | * not change, state of other planes, since it avoids threading an error code |
753 | * back up the call chain. |
754 | * |
755 | * WARNING: |
756 | * |
757 | * Note that this function is in general unsafe since it doesn't check for the |
758 | * required locking for access state structures. Drivers must ensure that it is |
759 | * safe to access the returned state structure through other means. One common |
760 | * example is when planes are fixed to a single CRTC, and the driver knows that |
761 | * the CRTC lock is held already. In that case holding the CRTC lock gives a |
762 | * read-lock on all planes connected to that CRTC. But if planes can be |
763 | * reassigned things get more tricky. In that case it's better to use |
764 | * drm_atomic_get_plane_state and wire up full error handling. |
765 | * |
766 | * Returns: |
767 | * |
768 | * Read-only pointer to the current plane state. |
769 | */ |
770 | static inline const struct drm_plane_state * |
771 | __drm_atomic_get_current_plane_state(const struct drm_atomic_state *state, |
772 | struct drm_plane *plane) |
773 | { |
774 | if (state->planes[drm_plane_index(plane)].state) |
775 | return state->planes[drm_plane_index(plane)].state; |
776 | |
777 | return plane->state; |
778 | } |
779 | |
780 | int __must_check |
781 | drm_atomic_add_encoder_bridges(struct drm_atomic_state *state, |
782 | struct drm_encoder *encoder); |
783 | int __must_check |
784 | drm_atomic_add_affected_connectors(struct drm_atomic_state *state, |
785 | struct drm_crtc *crtc); |
786 | int __must_check |
787 | drm_atomic_add_affected_planes(struct drm_atomic_state *state, |
788 | struct drm_crtc *crtc); |
789 | |
790 | int __must_check drm_atomic_check_only(struct drm_atomic_state *state); |
791 | int __must_check drm_atomic_commit(struct drm_atomic_state *state); |
792 | int __must_check drm_atomic_nonblocking_commit(struct drm_atomic_state *state); |
793 | |
794 | void drm_state_dump(struct drm_device *dev, struct drm_printer *p); |
795 | |
796 | /** |
797 | * for_each_oldnew_connector_in_state - iterate over all connectors in an atomic update |
798 | * @__state: &struct drm_atomic_state pointer |
799 | * @connector: &struct drm_connector iteration cursor |
800 | * @old_connector_state: &struct drm_connector_state iteration cursor for the |
801 | * old state |
802 | * @new_connector_state: &struct drm_connector_state iteration cursor for the |
803 | * new state |
804 | * @__i: int iteration cursor, for macro-internal use |
805 | * |
806 | * This iterates over all connectors in an atomic update, tracking both old and |
807 | * new state. This is useful in places where the state delta needs to be |
808 | * considered, for example in atomic check functions. |
809 | */ |
810 | #define for_each_oldnew_connector_in_state(__state, connector, old_connector_state, new_connector_state, __i) \ |
811 | for ((__i) = 0; \ |
812 | (__i) < (__state)->num_connector; \ |
813 | (__i)++) \ |
814 | for_each_if ((__state)->connectors[__i].ptr && \ |
815 | ((connector) = (__state)->connectors[__i].ptr, \ |
816 | (void)(connector) /* Only to avoid unused-but-set-variable warning */, \ |
817 | (old_connector_state) = (__state)->connectors[__i].old_state, \ |
818 | (new_connector_state) = (__state)->connectors[__i].new_state, 1)) |
819 | |
820 | /** |
821 | * for_each_old_connector_in_state - iterate over all connectors in an atomic update |
822 | * @__state: &struct drm_atomic_state pointer |
823 | * @connector: &struct drm_connector iteration cursor |
824 | * @old_connector_state: &struct drm_connector_state iteration cursor for the |
825 | * old state |
826 | * @__i: int iteration cursor, for macro-internal use |
827 | * |
828 | * This iterates over all connectors in an atomic update, tracking only the old |
829 | * state. This is useful in disable functions, where we need the old state the |
830 | * hardware is still in. |
831 | */ |
832 | #define for_each_old_connector_in_state(__state, connector, old_connector_state, __i) \ |
833 | for ((__i) = 0; \ |
834 | (__i) < (__state)->num_connector; \ |
835 | (__i)++) \ |
836 | for_each_if ((__state)->connectors[__i].ptr && \ |
837 | ((connector) = (__state)->connectors[__i].ptr, \ |
838 | (void)(connector) /* Only to avoid unused-but-set-variable warning */, \ |
839 | (old_connector_state) = (__state)->connectors[__i].old_state, 1)) |
840 | |
841 | /** |
842 | * for_each_new_connector_in_state - iterate over all connectors in an atomic update |
843 | * @__state: &struct drm_atomic_state pointer |
844 | * @connector: &struct drm_connector iteration cursor |
845 | * @new_connector_state: &struct drm_connector_state iteration cursor for the |
846 | * new state |
847 | * @__i: int iteration cursor, for macro-internal use |
848 | * |
849 | * This iterates over all connectors in an atomic update, tracking only the new |
850 | * state. This is useful in enable functions, where we need the new state the |
851 | * hardware should be in when the atomic commit operation has completed. |
852 | */ |
853 | #define for_each_new_connector_in_state(__state, connector, new_connector_state, __i) \ |
854 | for ((__i) = 0; \ |
855 | (__i) < (__state)->num_connector; \ |
856 | (__i)++) \ |
857 | for_each_if ((__state)->connectors[__i].ptr && \ |
858 | ((connector) = (__state)->connectors[__i].ptr, \ |
859 | (void)(connector) /* Only to avoid unused-but-set-variable warning */, \ |
860 | (new_connector_state) = (__state)->connectors[__i].new_state, \ |
861 | (void)(new_connector_state) /* Only to avoid unused-but-set-variable warning */, 1)) |
862 | |
863 | /** |
864 | * for_each_oldnew_crtc_in_state - iterate over all CRTCs in an atomic update |
865 | * @__state: &struct drm_atomic_state pointer |
866 | * @crtc: &struct drm_crtc iteration cursor |
867 | * @old_crtc_state: &struct drm_crtc_state iteration cursor for the old state |
868 | * @new_crtc_state: &struct drm_crtc_state iteration cursor for the new state |
869 | * @__i: int iteration cursor, for macro-internal use |
870 | * |
871 | * This iterates over all CRTCs in an atomic update, tracking both old and |
872 | * new state. This is useful in places where the state delta needs to be |
873 | * considered, for example in atomic check functions. |
874 | */ |
875 | #define for_each_oldnew_crtc_in_state(__state, crtc, old_crtc_state, new_crtc_state, __i) \ |
876 | for ((__i) = 0; \ |
877 | (__i) < (__state)->dev->mode_config.num_crtc; \ |
878 | (__i)++) \ |
879 | for_each_if ((__state)->crtcs[__i].ptr && \ |
880 | ((crtc) = (__state)->crtcs[__i].ptr, \ |
881 | (void)(crtc) /* Only to avoid unused-but-set-variable warning */, \ |
882 | (old_crtc_state) = (__state)->crtcs[__i].old_state, \ |
883 | (void)(old_crtc_state) /* Only to avoid unused-but-set-variable warning */, \ |
884 | (new_crtc_state) = (__state)->crtcs[__i].new_state, \ |
885 | (void)(new_crtc_state) /* Only to avoid unused-but-set-variable warning */, 1)) |
886 | |
887 | /** |
888 | * for_each_old_crtc_in_state - iterate over all CRTCs in an atomic update |
889 | * @__state: &struct drm_atomic_state pointer |
890 | * @crtc: &struct drm_crtc iteration cursor |
891 | * @old_crtc_state: &struct drm_crtc_state iteration cursor for the old state |
892 | * @__i: int iteration cursor, for macro-internal use |
893 | * |
894 | * This iterates over all CRTCs in an atomic update, tracking only the old |
895 | * state. This is useful in disable functions, where we need the old state the |
896 | * hardware is still in. |
897 | */ |
898 | #define for_each_old_crtc_in_state(__state, crtc, old_crtc_state, __i) \ |
899 | for ((__i) = 0; \ |
900 | (__i) < (__state)->dev->mode_config.num_crtc; \ |
901 | (__i)++) \ |
902 | for_each_if ((__state)->crtcs[__i].ptr && \ |
903 | ((crtc) = (__state)->crtcs[__i].ptr, \ |
904 | (void)(crtc) /* Only to avoid unused-but-set-variable warning */, \ |
905 | (old_crtc_state) = (__state)->crtcs[__i].old_state, 1)) |
906 | |
907 | /** |
908 | * for_each_new_crtc_in_state - iterate over all CRTCs in an atomic update |
909 | * @__state: &struct drm_atomic_state pointer |
910 | * @crtc: &struct drm_crtc iteration cursor |
911 | * @new_crtc_state: &struct drm_crtc_state iteration cursor for the new state |
912 | * @__i: int iteration cursor, for macro-internal use |
913 | * |
914 | * This iterates over all CRTCs in an atomic update, tracking only the new |
915 | * state. This is useful in enable functions, where we need the new state the |
916 | * hardware should be in when the atomic commit operation has completed. |
917 | */ |
918 | #define for_each_new_crtc_in_state(__state, crtc, new_crtc_state, __i) \ |
919 | for ((__i) = 0; \ |
920 | (__i) < (__state)->dev->mode_config.num_crtc; \ |
921 | (__i)++) \ |
922 | for_each_if ((__state)->crtcs[__i].ptr && \ |
923 | ((crtc) = (__state)->crtcs[__i].ptr, \ |
924 | (void)(crtc) /* Only to avoid unused-but-set-variable warning */, \ |
925 | (new_crtc_state) = (__state)->crtcs[__i].new_state, \ |
926 | (void)(new_crtc_state) /* Only to avoid unused-but-set-variable warning */, 1)) |
927 | |
928 | /** |
929 | * for_each_oldnew_plane_in_state - iterate over all planes in an atomic update |
930 | * @__state: &struct drm_atomic_state pointer |
931 | * @plane: &struct drm_plane iteration cursor |
932 | * @old_plane_state: &struct drm_plane_state iteration cursor for the old state |
933 | * @new_plane_state: &struct drm_plane_state iteration cursor for the new state |
934 | * @__i: int iteration cursor, for macro-internal use |
935 | * |
936 | * This iterates over all planes in an atomic update, tracking both old and |
937 | * new state. This is useful in places where the state delta needs to be |
938 | * considered, for example in atomic check functions. |
939 | */ |
940 | #define for_each_oldnew_plane_in_state(__state, plane, old_plane_state, new_plane_state, __i) \ |
941 | for ((__i) = 0; \ |
942 | (__i) < (__state)->dev->mode_config.num_total_plane; \ |
943 | (__i)++) \ |
944 | for_each_if ((__state)->planes[__i].ptr && \ |
945 | ((plane) = (__state)->planes[__i].ptr, \ |
946 | (void)(plane) /* Only to avoid unused-but-set-variable warning */, \ |
947 | (old_plane_state) = (__state)->planes[__i].old_state,\ |
948 | (new_plane_state) = (__state)->planes[__i].new_state, 1)) |
949 | |
950 | /** |
951 | * for_each_oldnew_plane_in_state_reverse - iterate over all planes in an atomic |
952 | * update in reverse order |
953 | * @__state: &struct drm_atomic_state pointer |
954 | * @plane: &struct drm_plane iteration cursor |
955 | * @old_plane_state: &struct drm_plane_state iteration cursor for the old state |
956 | * @new_plane_state: &struct drm_plane_state iteration cursor for the new state |
957 | * @__i: int iteration cursor, for macro-internal use |
958 | * |
959 | * This iterates over all planes in an atomic update in reverse order, |
960 | * tracking both old and new state. This is useful in places where the |
961 | * state delta needs to be considered, for example in atomic check functions. |
962 | */ |
963 | #define for_each_oldnew_plane_in_state_reverse(__state, plane, old_plane_state, new_plane_state, __i) \ |
964 | for ((__i) = ((__state)->dev->mode_config.num_total_plane - 1); \ |
965 | (__i) >= 0; \ |
966 | (__i)--) \ |
967 | for_each_if ((__state)->planes[__i].ptr && \ |
968 | ((plane) = (__state)->planes[__i].ptr, \ |
969 | (old_plane_state) = (__state)->planes[__i].old_state,\ |
970 | (new_plane_state) = (__state)->planes[__i].new_state, 1)) |
971 | |
972 | /** |
973 | * for_each_new_plane_in_state_reverse - other than only tracking new state, |
974 | * it's the same as for_each_oldnew_plane_in_state_reverse |
975 | * @__state: &struct drm_atomic_state pointer |
976 | * @plane: &struct drm_plane iteration cursor |
977 | * @new_plane_state: &struct drm_plane_state iteration cursor for the new state |
978 | * @__i: int iteration cursor, for macro-internal use |
979 | */ |
980 | #define for_each_new_plane_in_state_reverse(__state, plane, new_plane_state, __i) \ |
981 | for ((__i) = ((__state)->dev->mode_config.num_total_plane - 1); \ |
982 | (__i) >= 0; \ |
983 | (__i)--) \ |
984 | for_each_if ((__state)->planes[__i].ptr && \ |
985 | ((plane) = (__state)->planes[__i].ptr, \ |
986 | (new_plane_state) = (__state)->planes[__i].new_state, 1)) |
987 | |
988 | /** |
989 | * for_each_old_plane_in_state - iterate over all planes in an atomic update |
990 | * @__state: &struct drm_atomic_state pointer |
991 | * @plane: &struct drm_plane iteration cursor |
992 | * @old_plane_state: &struct drm_plane_state iteration cursor for the old state |
993 | * @__i: int iteration cursor, for macro-internal use |
994 | * |
995 | * This iterates over all planes in an atomic update, tracking only the old |
996 | * state. This is useful in disable functions, where we need the old state the |
997 | * hardware is still in. |
998 | */ |
999 | #define for_each_old_plane_in_state(__state, plane, old_plane_state, __i) \ |
1000 | for ((__i) = 0; \ |
1001 | (__i) < (__state)->dev->mode_config.num_total_plane; \ |
1002 | (__i)++) \ |
1003 | for_each_if ((__state)->planes[__i].ptr && \ |
1004 | ((plane) = (__state)->planes[__i].ptr, \ |
1005 | (old_plane_state) = (__state)->planes[__i].old_state, 1)) |
1006 | /** |
1007 | * for_each_new_plane_in_state - iterate over all planes in an atomic update |
1008 | * @__state: &struct drm_atomic_state pointer |
1009 | * @plane: &struct drm_plane iteration cursor |
1010 | * @new_plane_state: &struct drm_plane_state iteration cursor for the new state |
1011 | * @__i: int iteration cursor, for macro-internal use |
1012 | * |
1013 | * This iterates over all planes in an atomic update, tracking only the new |
1014 | * state. This is useful in enable functions, where we need the new state the |
1015 | * hardware should be in when the atomic commit operation has completed. |
1016 | */ |
1017 | #define for_each_new_plane_in_state(__state, plane, new_plane_state, __i) \ |
1018 | for ((__i) = 0; \ |
1019 | (__i) < (__state)->dev->mode_config.num_total_plane; \ |
1020 | (__i)++) \ |
1021 | for_each_if ((__state)->planes[__i].ptr && \ |
1022 | ((plane) = (__state)->planes[__i].ptr, \ |
1023 | (void)(plane) /* Only to avoid unused-but-set-variable warning */, \ |
1024 | (new_plane_state) = (__state)->planes[__i].new_state, \ |
1025 | (void)(new_plane_state) /* Only to avoid unused-but-set-variable warning */, 1)) |
1026 | |
1027 | /** |
1028 | * for_each_oldnew_private_obj_in_state - iterate over all private objects in an atomic update |
1029 | * @__state: &struct drm_atomic_state pointer |
1030 | * @obj: &struct drm_private_obj iteration cursor |
1031 | * @old_obj_state: &struct drm_private_state iteration cursor for the old state |
1032 | * @new_obj_state: &struct drm_private_state iteration cursor for the new state |
1033 | * @__i: int iteration cursor, for macro-internal use |
1034 | * |
1035 | * This iterates over all private objects in an atomic update, tracking both |
1036 | * old and new state. This is useful in places where the state delta needs |
1037 | * to be considered, for example in atomic check functions. |
1038 | */ |
1039 | #define for_each_oldnew_private_obj_in_state(__state, obj, old_obj_state, new_obj_state, __i) \ |
1040 | for ((__i) = 0; \ |
1041 | (__i) < (__state)->num_private_objs && \ |
1042 | ((obj) = (__state)->private_objs[__i].ptr, \ |
1043 | (old_obj_state) = (__state)->private_objs[__i].old_state, \ |
1044 | (new_obj_state) = (__state)->private_objs[__i].new_state, 1); \ |
1045 | (__i)++) |
1046 | |
1047 | /** |
1048 | * for_each_old_private_obj_in_state - iterate over all private objects in an atomic update |
1049 | * @__state: &struct drm_atomic_state pointer |
1050 | * @obj: &struct drm_private_obj iteration cursor |
1051 | * @old_obj_state: &struct drm_private_state iteration cursor for the old state |
1052 | * @__i: int iteration cursor, for macro-internal use |
1053 | * |
1054 | * This iterates over all private objects in an atomic update, tracking only |
1055 | * the old state. This is useful in disable functions, where we need the old |
1056 | * state the hardware is still in. |
1057 | */ |
1058 | #define for_each_old_private_obj_in_state(__state, obj, old_obj_state, __i) \ |
1059 | for ((__i) = 0; \ |
1060 | (__i) < (__state)->num_private_objs && \ |
1061 | ((obj) = (__state)->private_objs[__i].ptr, \ |
1062 | (old_obj_state) = (__state)->private_objs[__i].old_state, 1); \ |
1063 | (__i)++) |
1064 | |
1065 | /** |
1066 | * for_each_new_private_obj_in_state - iterate over all private objects in an atomic update |
1067 | * @__state: &struct drm_atomic_state pointer |
1068 | * @obj: &struct drm_private_obj iteration cursor |
1069 | * @new_obj_state: &struct drm_private_state iteration cursor for the new state |
1070 | * @__i: int iteration cursor, for macro-internal use |
1071 | * |
1072 | * This iterates over all private objects in an atomic update, tracking only |
1073 | * the new state. This is useful in enable functions, where we need the new state the |
1074 | * hardware should be in when the atomic commit operation has completed. |
1075 | */ |
1076 | #define for_each_new_private_obj_in_state(__state, obj, new_obj_state, __i) \ |
1077 | for ((__i) = 0; \ |
1078 | (__i) < (__state)->num_private_objs && \ |
1079 | ((obj) = (__state)->private_objs[__i].ptr, \ |
1080 | (void)(obj) /* Only to avoid unused-but-set-variable warning */, \ |
1081 | (new_obj_state) = (__state)->private_objs[__i].new_state, 1); \ |
1082 | (__i)++) |
1083 | |
1084 | /** |
1085 | * drm_atomic_crtc_needs_modeset - compute combined modeset need |
1086 | * @state: &drm_crtc_state for the CRTC |
1087 | * |
1088 | * To give drivers flexibility &struct drm_crtc_state has 3 booleans to track |
1089 | * whether the state CRTC changed enough to need a full modeset cycle: |
1090 | * mode_changed, active_changed and connectors_changed. This helper simply |
1091 | * combines these three to compute the overall need for a modeset for @state. |
1092 | * |
1093 | * The atomic helper code sets these booleans, but drivers can and should |
1094 | * change them appropriately to accurately represent whether a modeset is |
1095 | * really needed. In general, drivers should avoid full modesets whenever |
1096 | * possible. |
1097 | * |
1098 | * For example if the CRTC mode has changed, and the hardware is able to enact |
1099 | * the requested mode change without going through a full modeset, the driver |
1100 | * should clear mode_changed in its &drm_mode_config_funcs.atomic_check |
1101 | * implementation. |
1102 | */ |
1103 | static inline bool |
1104 | drm_atomic_crtc_needs_modeset(const struct drm_crtc_state *state) |
1105 | { |
1106 | return state->mode_changed || state->active_changed || |
1107 | state->connectors_changed; |
1108 | } |
1109 | |
1110 | /** |
1111 | * drm_atomic_crtc_effectively_active - compute whether CRTC is actually active |
1112 | * @state: &drm_crtc_state for the CRTC |
1113 | * |
1114 | * When in self refresh mode, the crtc_state->active value will be false, since |
1115 | * the CRTC is off. However in some cases we're interested in whether the CRTC |
1116 | * is active, or effectively active (ie: it's connected to an active display). |
1117 | * In these cases, use this function instead of just checking active. |
1118 | */ |
1119 | static inline bool |
1120 | drm_atomic_crtc_effectively_active(const struct drm_crtc_state *state) |
1121 | { |
1122 | return state->active || state->self_refresh_active; |
1123 | } |
1124 | |
1125 | /** |
1126 | * struct drm_bus_cfg - bus configuration |
1127 | * |
1128 | * This structure stores the configuration of a physical bus between two |
1129 | * components in an output pipeline, usually between two bridges, an encoder |
1130 | * and a bridge, or a bridge and a connector. |
1131 | * |
1132 | * The bus configuration is stored in &drm_bridge_state separately for the |
1133 | * input and output buses, as seen from the point of view of each bridge. The |
1134 | * bus configuration of a bridge output is usually identical to the |
1135 | * configuration of the next bridge's input, but may differ if the signals are |
1136 | * modified between the two bridges, for instance by an inverter on the board. |
1137 | * The input and output configurations of a bridge may differ if the bridge |
1138 | * modifies the signals internally, for instance by performing format |
1139 | * conversion, or modifying signals polarities. |
1140 | */ |
1141 | struct drm_bus_cfg { |
1142 | /** |
1143 | * @format: format used on this bus (one of the MEDIA_BUS_FMT_* format) |
1144 | * |
1145 | * This field should not be directly modified by drivers |
1146 | * (drm_atomic_bridge_chain_select_bus_fmts() takes care of the bus |
1147 | * format negotiation). |
1148 | */ |
1149 | u32 format; |
1150 | |
1151 | /** |
1152 | * @flags: DRM_BUS_* flags used on this bus |
1153 | */ |
1154 | u32 flags; |
1155 | }; |
1156 | |
1157 | /** |
1158 | * struct drm_bridge_state - Atomic bridge state object |
1159 | */ |
1160 | struct drm_bridge_state { |
1161 | /** |
1162 | * @base: inherit from &drm_private_state |
1163 | */ |
1164 | struct drm_private_state base; |
1165 | |
1166 | /** |
1167 | * @bridge: the bridge this state refers to |
1168 | */ |
1169 | struct drm_bridge *bridge; |
1170 | |
1171 | /** |
1172 | * @input_bus_cfg: input bus configuration |
1173 | */ |
1174 | struct drm_bus_cfg input_bus_cfg; |
1175 | |
1176 | /** |
1177 | * @output_bus_cfg: output bus configuration |
1178 | */ |
1179 | struct drm_bus_cfg output_bus_cfg; |
1180 | }; |
1181 | |
1182 | static inline struct drm_bridge_state * |
1183 | drm_priv_to_bridge_state(struct drm_private_state *priv) |
1184 | { |
1185 | return container_of(priv, struct drm_bridge_state, base); |
1186 | } |
1187 | |
1188 | struct drm_bridge_state * |
1189 | drm_atomic_get_bridge_state(struct drm_atomic_state *state, |
1190 | struct drm_bridge *bridge); |
1191 | struct drm_bridge_state * |
1192 | drm_atomic_get_old_bridge_state(const struct drm_atomic_state *state, |
1193 | struct drm_bridge *bridge); |
1194 | struct drm_bridge_state * |
1195 | drm_atomic_get_new_bridge_state(const struct drm_atomic_state *state, |
1196 | struct drm_bridge *bridge); |
1197 | |
1198 | #endif /* DRM_ATOMIC_H_ */ |
1199 | |