2014-07-25 13:30:38 -06:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2014 Red Hat
|
|
|
|
* Copyright (C) 2014 Intel Corp.
|
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
|
|
* to deal in the Software without restriction, including without limitation
|
|
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice shall be included in
|
|
|
|
* all copies or substantial portions of the Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
|
* THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
|
|
|
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
|
|
|
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|
|
|
* OTHER DEALINGS IN THE SOFTWARE.
|
|
|
|
*
|
|
|
|
* Authors:
|
|
|
|
* Rob Clark <robdclark@gmail.com>
|
|
|
|
* Daniel Vetter <daniel.vetter@ffwll.ch>
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef DRM_ATOMIC_H_
|
|
|
|
#define DRM_ATOMIC_H_
|
|
|
|
|
2014-11-25 04:09:48 -07:00
|
|
|
#include <drm/drm_crtc.h>
|
2018-09-05 07:57:05 -06:00
|
|
|
#include <drm/drm_util.h>
|
2014-11-25 04:09:48 -07:00
|
|
|
|
2016-09-21 02:59:24 -06:00
|
|
|
/**
|
|
|
|
* struct drm_crtc_commit - track modeset commits on a CRTC
|
|
|
|
*
|
|
|
|
* This structure is used to track pending modeset changes and atomic commit on
|
2019-12-06 06:53:35 -07:00
|
|
|
* a per-CRTC basis. Since updating the list should never block, this structure
|
2016-09-21 02:59:24 -06:00
|
|
|
* is reference counted to allow waiters to safely wait on an event to complete,
|
|
|
|
* without holding any locks.
|
|
|
|
*
|
|
|
|
* It has 3 different events in total to allow a fine-grained synchronization
|
|
|
|
* between outstanding updates::
|
|
|
|
*
|
|
|
|
* atomic commit thread hardware
|
|
|
|
*
|
|
|
|
* write new state into hardware ----> ...
|
|
|
|
* signal hw_done
|
|
|
|
* switch to new state on next
|
|
|
|
* ... v/hblank
|
|
|
|
*
|
|
|
|
* wait for buffers to show up ...
|
|
|
|
*
|
|
|
|
* ... send completion irq
|
|
|
|
* irq handler signals flip_done
|
|
|
|
* cleanup old buffers
|
|
|
|
*
|
|
|
|
* signal cleanup_done
|
|
|
|
*
|
|
|
|
* wait for flip_done <----
|
|
|
|
* clean up atomic state
|
|
|
|
*
|
2019-12-04 03:00:11 -07:00
|
|
|
* The important bit to know is that &cleanup_done is the terminal event, but the
|
|
|
|
* ordering between &flip_done and &hw_done is entirely up to the specific driver
|
2016-09-21 02:59:24 -06:00
|
|
|
* and modeset state change.
|
|
|
|
*
|
|
|
|
* For an implementation of how to use this look at
|
|
|
|
* drm_atomic_helper_setup_commit() from the atomic helper library.
|
|
|
|
*/
|
|
|
|
struct drm_crtc_commit {
|
|
|
|
/**
|
|
|
|
* @crtc:
|
|
|
|
*
|
|
|
|
* DRM CRTC for this commit.
|
|
|
|
*/
|
|
|
|
struct drm_crtc *crtc;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @ref:
|
|
|
|
*
|
|
|
|
* Reference count for this structure. Needed to allow blocking on
|
|
|
|
* completions without the risk of the completion disappearing
|
|
|
|
* meanwhile.
|
|
|
|
*/
|
|
|
|
struct kref ref;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @flip_done:
|
|
|
|
*
|
|
|
|
* Will be signaled when the hardware has flipped to the new set of
|
|
|
|
* buffers. Signals at the same time as when the drm event for this
|
|
|
|
* commit is sent to userspace, or when an out-fence is singalled. Note
|
|
|
|
* that for most hardware, in most cases this happens after @hw_done is
|
|
|
|
* signalled.
|
2019-12-04 03:00:11 -07:00
|
|
|
*
|
|
|
|
* Completion of this stage is signalled implicitly by calling
|
|
|
|
* drm_crtc_send_vblank_event() on &drm_crtc_state.event.
|
2016-09-21 02:59:24 -06:00
|
|
|
*/
|
|
|
|
struct completion flip_done;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @hw_done:
|
|
|
|
*
|
|
|
|
* Will be signalled when all hw register changes for this commit have
|
|
|
|
* been written out. Especially when disabling a pipe this can be much
|
2020-07-14 23:23:43 -06:00
|
|
|
* later than @flip_done, since that can signal already when the
|
2016-09-21 02:59:24 -06:00
|
|
|
* screen goes black, whereas to fully shut down a pipe more register
|
|
|
|
* I/O is required.
|
|
|
|
*
|
|
|
|
* Note that this does not need to include separately reference-counted
|
|
|
|
* resources like backing storage buffer pinning, or runtime pm
|
|
|
|
* management.
|
2019-12-04 03:00:11 -07:00
|
|
|
*
|
|
|
|
* Drivers should call drm_atomic_helper_commit_hw_done() to signal
|
|
|
|
* completion of this stage.
|
2016-09-21 02:59:24 -06:00
|
|
|
*/
|
|
|
|
struct completion hw_done;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @cleanup_done:
|
|
|
|
*
|
|
|
|
* Will be signalled after old buffers have been cleaned up by calling
|
|
|
|
* drm_atomic_helper_cleanup_planes(). Since this can only happen after
|
|
|
|
* a vblank wait completed it might be a bit later. This completion is
|
|
|
|
* useful to throttle updates and avoid hardware updates getting ahead
|
|
|
|
* of the buffer cleanup too much.
|
2019-12-04 03:00:11 -07:00
|
|
|
*
|
|
|
|
* Drivers should call drm_atomic_helper_commit_cleanup_done() to signal
|
|
|
|
* completion of this stage.
|
2016-09-21 02:59:24 -06:00
|
|
|
*/
|
|
|
|
struct completion cleanup_done;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @commit_entry:
|
|
|
|
*
|
2017-01-24 23:26:45 -07:00
|
|
|
* Entry on the per-CRTC &drm_crtc.commit_list. Protected by
|
|
|
|
* $drm_crtc.commit_lock.
|
2016-09-21 02:59:24 -06:00
|
|
|
*/
|
|
|
|
struct list_head commit_entry;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @event:
|
|
|
|
*
|
|
|
|
* &drm_pending_vblank_event pointer to clean up private events.
|
|
|
|
*/
|
|
|
|
struct drm_pending_vblank_event *event;
|
2018-01-17 04:51:08 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @abort_completion:
|
|
|
|
*
|
2018-10-12 01:34:41 -06:00
|
|
|
* A flag that's set after drm_atomic_helper_setup_commit() takes a
|
|
|
|
* second reference for the completion of $drm_crtc_state.event. It's
|
|
|
|
* used by the free code to remove the second reference if commit fails.
|
2018-01-17 04:51:08 -07:00
|
|
|
*/
|
|
|
|
bool abort_completion;
|
2016-09-21 02:59:24 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
struct __drm_planes_state {
|
|
|
|
struct drm_plane *ptr;
|
2017-01-16 02:37:38 -07:00
|
|
|
struct drm_plane_state *state, *old_state, *new_state;
|
2016-09-21 02:59:24 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
struct __drm_crtcs_state {
|
|
|
|
struct drm_crtc *ptr;
|
2017-01-16 02:37:38 -07:00
|
|
|
struct drm_crtc_state *state, *old_state, *new_state;
|
2018-10-15 07:46:40 -06:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @commit:
|
|
|
|
*
|
|
|
|
* A reference to the CRTC commit object that is kept for use by
|
|
|
|
* drm_atomic_helper_wait_for_flip_done() after
|
|
|
|
* drm_atomic_helper_commit_hw_done() is called. This ensures that a
|
|
|
|
* concurrent commit won't free a commit object that is still in use.
|
|
|
|
*/
|
|
|
|
struct drm_crtc_commit *commit;
|
|
|
|
|
2017-01-13 07:22:09 -07:00
|
|
|
s32 __user *out_fence_ptr;
|
2018-02-02 22:12:59 -07:00
|
|
|
u64 last_vblank_count;
|
2016-09-21 02:59:24 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
struct __drm_connnectors_state {
|
|
|
|
struct drm_connector *ptr;
|
2017-01-16 02:37:38 -07:00
|
|
|
struct drm_connector_state *state, *old_state, *new_state;
|
2017-03-29 10:42:33 -06:00
|
|
|
/**
|
|
|
|
* @out_fence_ptr:
|
|
|
|
*
|
|
|
|
* User-provided pointer which the kernel uses to return a sync_file
|
|
|
|
* file descriptor. Used by writeback connectors to signal completion of
|
|
|
|
* the writeback.
|
|
|
|
*/
|
|
|
|
s32 __user *out_fence_ptr;
|
2016-09-21 02:59:24 -06:00
|
|
|
};
|
|
|
|
|
2017-07-12 09:51:02 -06:00
|
|
|
struct drm_private_obj;
|
|
|
|
struct drm_private_state;
|
|
|
|
|
2017-04-20 23:51:30 -06:00
|
|
|
/**
|
|
|
|
* struct drm_private_state_funcs - atomic state functions for private objects
|
|
|
|
*
|
|
|
|
* These hooks are used by atomic helpers to create, swap and destroy states of
|
|
|
|
* private objects. The structure itself is used as a vtable to identify the
|
|
|
|
* associated private object type. Each private object type that needs to be
|
|
|
|
* added to the atomic states is expected to have an implementation of these
|
2019-02-01 18:23:26 -07:00
|
|
|
* hooks and pass a pointer to its drm_private_state_funcs struct to
|
2017-04-20 23:51:30 -06:00
|
|
|
* drm_atomic_get_private_obj_state().
|
|
|
|
*/
|
|
|
|
struct drm_private_state_funcs {
|
|
|
|
/**
|
2017-07-12 09:51:02 -06:00
|
|
|
* @atomic_duplicate_state:
|
2017-04-20 23:51:30 -06:00
|
|
|
*
|
|
|
|
* Duplicate the current state of the private object and return it. It
|
|
|
|
* is an error to call this before obj->state has been initialized.
|
|
|
|
*
|
|
|
|
* RETURNS:
|
|
|
|
*
|
|
|
|
* Duplicated atomic state or NULL when obj->state is not
|
|
|
|
* initialized or allocation failed.
|
|
|
|
*/
|
2017-07-12 09:51:02 -06:00
|
|
|
struct drm_private_state *(*atomic_duplicate_state)(struct drm_private_obj *obj);
|
2017-04-20 23:51:30 -06:00
|
|
|
|
|
|
|
/**
|
2017-07-12 09:51:02 -06:00
|
|
|
* @atomic_destroy_state:
|
2017-04-20 23:51:30 -06:00
|
|
|
*
|
2017-07-12 09:51:02 -06:00
|
|
|
* Frees the private object state created with @atomic_duplicate_state.
|
2017-04-20 23:51:30 -06:00
|
|
|
*/
|
2017-07-12 09:51:02 -06:00
|
|
|
void (*atomic_destroy_state)(struct drm_private_obj *obj,
|
|
|
|
struct drm_private_state *state);
|
|
|
|
};
|
2017-04-20 23:51:30 -06:00
|
|
|
|
2017-12-14 13:30:53 -07:00
|
|
|
/**
|
|
|
|
* struct drm_private_obj - base struct for driver private atomic object
|
|
|
|
*
|
|
|
|
* A driver private object is initialized by calling
|
|
|
|
* drm_atomic_private_obj_init() and cleaned up by calling
|
|
|
|
* drm_atomic_private_obj_fini().
|
|
|
|
*
|
|
|
|
* Currently only tracks the state update functions and the opaque driver
|
|
|
|
* private state itself, but in the future might also track which
|
|
|
|
* &drm_modeset_lock is required to duplicate and update this object's state.
|
2018-10-22 06:31:22 -06:00
|
|
|
*
|
|
|
|
* All private objects must be initialized before the DRM device they are
|
|
|
|
* attached to is registered to the DRM subsystem (call to drm_dev_register())
|
|
|
|
* and should stay around until this DRM device is unregistered (call to
|
|
|
|
* drm_dev_unregister()). In other words, private objects lifetime is tied
|
|
|
|
* to the DRM device lifetime. This implies that:
|
|
|
|
*
|
|
|
|
* 1/ all calls to drm_atomic_private_obj_init() must be done before calling
|
|
|
|
* drm_dev_register()
|
|
|
|
* 2/ all calls to drm_atomic_private_obj_fini() must be done after calling
|
|
|
|
* drm_dev_unregister()
|
2017-12-14 13:30:53 -07:00
|
|
|
*/
|
2017-07-12 09:51:02 -06:00
|
|
|
struct drm_private_obj {
|
2018-10-22 06:31:22 -06:00
|
|
|
/**
|
|
|
|
* @head: List entry used to attach a private object to a &drm_device
|
|
|
|
* (queued to &drm_mode_config.privobj_list).
|
|
|
|
*/
|
|
|
|
struct list_head head;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @lock: Modeset lock to protect the state object.
|
|
|
|
*/
|
|
|
|
struct drm_modeset_lock lock;
|
|
|
|
|
2017-12-14 13:30:53 -07:00
|
|
|
/**
|
|
|
|
* @state: Current atomic state for this driver private object.
|
|
|
|
*/
|
2017-07-12 09:51:02 -06:00
|
|
|
struct drm_private_state *state;
|
|
|
|
|
2017-12-14 13:30:53 -07:00
|
|
|
/**
|
|
|
|
* @funcs:
|
|
|
|
*
|
|
|
|
* Functions to manipulate the state of this driver private object, see
|
|
|
|
* &drm_private_state_funcs.
|
|
|
|
*/
|
2017-07-12 09:51:02 -06:00
|
|
|
const struct drm_private_state_funcs *funcs;
|
|
|
|
};
|
|
|
|
|
2018-10-22 06:31:22 -06:00
|
|
|
/**
|
|
|
|
* drm_for_each_privobj() - private object iterator
|
|
|
|
*
|
|
|
|
* @privobj: pointer to the current private object. Updated after each
|
|
|
|
* iteration
|
|
|
|
* @dev: the DRM device we want get private objects from
|
|
|
|
*
|
|
|
|
* Allows one to iterate over all private objects attached to @dev
|
|
|
|
*/
|
|
|
|
#define drm_for_each_privobj(privobj, dev) \
|
|
|
|
list_for_each_entry(privobj, &(dev)->mode_config.privobj_list, head)
|
|
|
|
|
2017-12-14 13:30:53 -07:00
|
|
|
/**
|
|
|
|
* struct drm_private_state - base struct for driver private object state
|
|
|
|
* @state: backpointer to global drm_atomic_state
|
|
|
|
*
|
|
|
|
* Currently only contains a backpointer to the overall atomic update, but in
|
|
|
|
* the future also might hold synchronization information similar to e.g.
|
|
|
|
* &drm_crtc.commit.
|
|
|
|
*/
|
2017-07-12 09:51:02 -06:00
|
|
|
struct drm_private_state {
|
|
|
|
struct drm_atomic_state *state;
|
2017-04-20 23:51:30 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
struct __drm_private_objs_state {
|
2017-07-12 09:51:02 -06:00
|
|
|
struct drm_private_obj *ptr;
|
|
|
|
struct drm_private_state *state, *old_state, *new_state;
|
2017-04-20 23:51:30 -06:00
|
|
|
};
|
|
|
|
|
2016-09-21 02:59:24 -06:00
|
|
|
/**
|
|
|
|
* struct drm_atomic_state - the global state object for atomic updates
|
2016-10-14 06:18:18 -06:00
|
|
|
* @ref: count of all references to this state (will not be freed until zero)
|
2016-09-21 02:59:24 -06:00
|
|
|
* @dev: parent DRM device
|
|
|
|
* @legacy_cursor_update: hint to enforce legacy cursor IOCTL semantics
|
2017-06-30 12:03:17 -06:00
|
|
|
* @async_update: hint for asynchronous plane update
|
2016-09-21 02:59:24 -06:00
|
|
|
* @planes: pointer to array of structures with per-plane data
|
|
|
|
* @crtcs: pointer to array of CRTC pointers
|
|
|
|
* @num_connector: size of the @connectors and @connector_states arrays
|
|
|
|
* @connectors: pointer to array of structures with per-connector data
|
2017-04-20 23:51:30 -06:00
|
|
|
* @num_private_objs: size of the @private_objs array
|
|
|
|
* @private_objs: pointer to array of private object pointers
|
2016-09-21 02:59:24 -06:00
|
|
|
* @acquire_ctx: acquire context for this atomic modeset state update
|
2017-12-14 13:30:54 -07:00
|
|
|
*
|
|
|
|
* States are added to an atomic update by calling drm_atomic_get_crtc_state(),
|
|
|
|
* drm_atomic_get_plane_state(), drm_atomic_get_connector_state(), or for
|
|
|
|
* private state structures, drm_atomic_get_private_obj_state().
|
2016-09-21 02:59:24 -06:00
|
|
|
*/
|
|
|
|
struct drm_atomic_state {
|
2016-10-14 06:18:18 -06:00
|
|
|
struct kref ref;
|
|
|
|
|
2016-09-21 02:59:24 -06:00
|
|
|
struct drm_device *dev;
|
2018-10-04 14:24:31 -06:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @allow_modeset:
|
|
|
|
*
|
|
|
|
* Allow full modeset. This is used by the ATOMIC IOCTL handler to
|
|
|
|
* implement the DRM_MODE_ATOMIC_ALLOW_MODESET flag. Drivers should
|
|
|
|
* never consult this flag, instead looking at the output of
|
|
|
|
* drm_atomic_crtc_needs_modeset().
|
|
|
|
*/
|
2016-09-21 02:59:24 -06:00
|
|
|
bool allow_modeset : 1;
|
|
|
|
bool legacy_cursor_update : 1;
|
2017-06-30 12:03:17 -06:00
|
|
|
bool async_update : 1;
|
drm/atomic: Add drm_atomic_state->duplicated
Since
commit 39b50c603878 ("drm/atomic_helper: Stop modesets on unregistered
connectors harder")
We've been failing atomic checks if they try to enable new displays on
unregistered connectors. This is fine except for the one situation that
breaks atomic assumptions: suspend/resume. If a connector is
unregistered before we attempt to restore the atomic state, something we
end up failing the atomic check that happens when trying to restore the
state during resume.
Normally this would be OK: we try our best to make sure that the atomic
state pre-suspend can be restored post-suspend, but failures at that
point usually don't cause problems. That is of course, until we
introduced the new atomic MST VCPI helpers:
[drm:drm_atomic_helper_check_modeset [drm_kms_helper]] [CRTC:65:pipe B] active changed
[drm:drm_atomic_helper_check_modeset [drm_kms_helper]] Updating routing for [CONNECTOR:123:DP-5]
[drm:drm_atomic_helper_check_modeset [drm_kms_helper]] Disabling [CONNECTOR:123:DP-5]
[drm:drm_atomic_get_private_obj_state [drm]] Added new private object 0000000025844636 state 000000009fd2899a to 000000003a13d7b8
WARNING: CPU: 6 PID: 1070 at drivers/gpu/drm/drm_dp_mst_topology.c:3153 drm_dp_atomic_release_vcpi_slots+0xb9/0x200 [drm_kms_helper]
Modules linked in: fuse vfat fat snd_hda_codec_hdmi snd_hda_codec_realtek snd_hda_codec_generic joydev iTCO_wdt i915(O) wmi_bmof intel_rapl btusb btrtl x86_pkg_temp_thermal btbcm btintel coretemp i2c_algo_bit drm_kms_helper(O) crc32_pclmul snd_hda_intel syscopyarea sysfillrect snd_hda_codec sysimgblt snd_hda_core bluetooth fb_sys_fops snd_pcm pcspkr drm(O) psmouse snd_timer mei_me ecdh_generic i2c_i801 mei i2c_core ucsi_acpi typec_ucsi typec wmi thinkpad_acpi ledtrig_audio snd soundcore tpm_tis rfkill tpm_tis_core video tpm acpi_pad pcc_cpufreq uas usb_storage crc32c_intel nvme serio_raw xhci_pci nvme_core xhci_hcd
CPU: 6 PID: 1070 Comm: gnome-shell Tainted: G W O 5.0.0-rc2Lyude-Test+ #1
Hardware name: LENOVO 20L8S2N800/20L8S2N800, BIOS N22ET35W (1.12 ) 04/09/2018
RIP: 0010:drm_dp_atomic_release_vcpi_slots+0xb9/0x200 [drm_kms_helper]
Code: 00 4c 39 6d f0 74 49 48 8d 7b 10 48 89 f9 48 c1 e9 03 42 80 3c 21 00 0f 85 d2 00 00 00 48 8b 6b 10 48 8d 5d f0 49 39 ee 75 c5 <0f> 0b 48 c7 c7 c0 78 b3 a0 48 89 c2 4c 89 ee e8 03 6c aa ff b8 ea
RSP: 0018:ffff88841235f268 EFLAGS: 00010246
RAX: ffff88841bf12ab0 RBX: ffff88841bf12aa8 RCX: 1ffff110837e2557
RDX: dffffc0000000000 RSI: 0000000000000000 RDI: ffffed108246bde0
RBP: ffff88841bf12ab8 R08: ffffed1083db3c93 R09: ffffed1083db3c92
R10: ffffed1083db3c92 R11: ffff88841ed9e497 R12: ffff888419555d80
R13: ffff8883bc499100 R14: ffff88841bf12ab8 R15: 0000000000000000
FS: 00007f16fbd4cd00(0000) GS:ffff88841ed80000(0000) knlGS:0000000000000000
CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
CR2: 00007f1687c9f000 CR3: 00000003ba3cc003 CR4: 00000000003606e0
DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000
DR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: 0000000000000400
Call Trace:
drm_atomic_helper_check_modeset+0xf21/0x2f50 [drm_kms_helper]
? drm_atomic_helper_commit_modeset_enables+0xa90/0xa90 [drm_kms_helper]
? __printk_safe_exit+0x10/0x10
? save_stack+0x8c/0xb0
? vprintk_func+0x96/0x1bf
? __printk_safe_exit+0x10/0x10
intel_atomic_check+0x234/0x4750 [i915]
? printk+0x9f/0xc5
? kmsg_dump_rewind_nolock+0xd9/0xd9
? _raw_spin_lock_irqsave+0xa4/0x140
? drm_atomic_check_only+0xb1/0x28b0 [drm]
? drm_dbg+0x186/0x1b0 [drm]
? drm_dev_dbg+0x200/0x200 [drm]
? intel_link_compute_m_n+0xb0/0xb0 [i915]
? drm_mode_put_tile_group+0x20/0x20 [drm]
? skl_plane_format_mod_supported+0x17f/0x1b0 [i915]
? drm_plane_check_pixel_format+0x14a/0x310 [drm]
drm_atomic_check_only+0x13c4/0x28b0 [drm]
? drm_state_info+0x220/0x220 [drm]
? drm_atomic_helper_disable_plane+0x1d0/0x1d0 [drm_kms_helper]
? pick_single_encoder_for_connector+0xe0/0xe0 [drm_kms_helper]
? kasan_unpoison_shadow+0x35/0x40
drm_atomic_commit+0x3b/0x100 [drm]
drm_atomic_helper_set_config+0xd5/0x100 [drm_kms_helper]
drm_mode_setcrtc+0x636/0x1660 [drm]
? vprintk_func+0x96/0x1bf
? drm_dev_dbg+0x200/0x200 [drm]
? drm_mode_getcrtc+0x790/0x790 [drm]
? printk+0x9f/0xc5
? mutex_unlock+0x1d/0x40
? drm_mode_addfb2+0x2e9/0x3a0 [drm]
? rcu_sync_dtor+0x2e0/0x2e0
? drm_dbg+0x186/0x1b0 [drm]
? set_page_dirty+0x271/0x4d0
drm_ioctl_kernel+0x203/0x290 [drm]
? drm_mode_getcrtc+0x790/0x790 [drm]
? drm_setversion+0x7f0/0x7f0 [drm]
? __switch_to_asm+0x34/0x70
? __switch_to_asm+0x34/0x70
drm_ioctl+0x445/0x950 [drm]
? drm_mode_getcrtc+0x790/0x790 [drm]
? drm_getunique+0x220/0x220 [drm]
? expand_files.part.10+0x920/0x920
do_vfs_ioctl+0x1a1/0x13d0
? ioctl_preallocate+0x2b0/0x2b0
? __fget_light+0x2d6/0x390
? schedule+0xd7/0x2e0
? fget_raw+0x10/0x10
? apic_timer_interrupt+0xa/0x20
? apic_timer_interrupt+0xa/0x20
? rcu_cleanup_dead_rnp+0x2c0/0x2c0
ksys_ioctl+0x60/0x90
__x64_sys_ioctl+0x6f/0xb0
do_syscall_64+0x136/0x440
? syscall_return_slowpath+0x2d0/0x2d0
? do_page_fault+0x89/0x330
? __do_page_fault+0x9c0/0x9c0
? prepare_exit_to_usermode+0x188/0x200
? perf_trace_sys_enter+0x1090/0x1090
? __x64_sys_sigaltstack+0x280/0x280
? __put_user_4+0x1c/0x30
entry_SYSCALL_64_after_hwframe+0x44/0xa9
RIP: 0033:0x7f16ff89a09b
Code: 0f 1e fa 48 8b 05 ed bd 0c 00 64 c7 00 26 00 00 00 48 c7 c0 ff ff ff ff c3 66 0f 1f 44 00 00 f3 0f 1e fa b8 10 00 00 00 0f 05 <48> 3d 01 f0 ff ff 73 01 c3 48 8b 0d bd bd 0c 00 f7 d8 64 89 01 48
RSP: 002b:00007fff001232b8 EFLAGS: 00000246 ORIG_RAX: 0000000000000010
RAX: ffffffffffffffda RBX: 00007fff001232f0 RCX: 00007f16ff89a09b
RDX: 00007fff001232f0 RSI: 00000000c06864a2 RDI: 000000000000000b
RBP: 00007fff001232f0 R08: 0000000000000000 R09: 000055a79d484460
R10: 000055a79d44e770 R11: 0000000000000246 R12: 00000000c06864a2
R13: 000000000000000b R14: 0000000000000000 R15: 000055a79d44e770
WARNING: CPU: 6 PID: 1070 at drivers/gpu/drm/drm_dp_mst_topology.c:3153 drm_dp_atomic_release_vcpi_slots+0xb9/0x200 [drm_kms_helper]
---[ end trace d536c05c13c83be2 ]---
[drm:drm_dp_atomic_release_vcpi_slots [drm_kms_helper]] *ERROR* no VCPI for [MST PORT:00000000f9e2b143] found in mst state 000000009fd2899a
This appears to be happening because we destroy the VCPI allocations
when disabling all connected displays while suspending, and those VCPI
allocations don't get restored on resume due to failing to restore the
atomic state.
So, fix this by introducing the suspending option to
drm_atomic_helper_duplicate_state() and use that to indicate in the
atomic state that it's being used for suspending or resuming the system,
and thus needs to be fixed up by the driver. We can then use the new
state->duplicated hook to tell update_connector_routing() in
drm_atomic_check_modeset() to allow for modesets on unregistered
connectors, which allows us to restore atomic states that contain MST
topologies that were removed after the state was duplicated and thus:
mostly fixing suspend and resume. This just leaves some issues that were
introduced with nouveau, that will be addressed next.
Changes since v3:
* Remove ->duplicated hunks that I left in the VCPI helpers by accident.
These don't need to be here, that was the supposed to be the purpose
of the last revision
Changes since v2:
* Remove the changes in this patch to the VCPI helpers, they aren't
needed anymore
Changes since v1:
* Rename suspend_or_resume to duplicated
Signed-off-by: Lyude Paul <lyude@redhat.com>
Fixes: eceae1472467 ("drm/dp_mst: Start tracking per-port VCPI allocations")
Cc: Daniel Vetter <daniel@ffwll.ch>
Reviewed-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Link: https://patchwork.freedesktop.org/patch/msgid/20190202002023.29665-4-lyude@redhat.com
2019-02-01 17:20:03 -07:00
|
|
|
/**
|
|
|
|
* @duplicated:
|
|
|
|
*
|
|
|
|
* Indicates whether or not this atomic state was duplicated using
|
|
|
|
* drm_atomic_helper_duplicate_state(). Drivers and atomic helpers
|
|
|
|
* should use this to fixup normal inconsistencies in duplicated
|
|
|
|
* states.
|
|
|
|
*/
|
|
|
|
bool duplicated : 1;
|
2016-09-21 02:59:24 -06:00
|
|
|
struct __drm_planes_state *planes;
|
|
|
|
struct __drm_crtcs_state *crtcs;
|
|
|
|
int num_connector;
|
|
|
|
struct __drm_connnectors_state *connectors;
|
2017-04-20 23:51:30 -06:00
|
|
|
int num_private_objs;
|
|
|
|
struct __drm_private_objs_state *private_objs;
|
2016-09-21 02:59:24 -06:00
|
|
|
|
|
|
|
struct drm_modeset_acquire_ctx *acquire_ctx;
|
|
|
|
|
2017-09-04 04:48:37 -06:00
|
|
|
/**
|
|
|
|
* @fake_commit:
|
|
|
|
*
|
|
|
|
* Used for signaling unbound planes/connectors.
|
|
|
|
* When a connector or plane is not bound to any CRTC, it's still important
|
|
|
|
* to preserve linearity to prevent the atomic states from being freed to early.
|
|
|
|
*
|
2019-12-06 06:53:36 -07:00
|
|
|
* This commit (if set) is not bound to any CRTC, but will be completed when
|
2017-09-04 04:48:37 -06:00
|
|
|
* drm_atomic_helper_commit_hw_done() is called.
|
|
|
|
*/
|
|
|
|
struct drm_crtc_commit *fake_commit;
|
|
|
|
|
2016-09-21 02:59:24 -06:00
|
|
|
/**
|
|
|
|
* @commit_work:
|
|
|
|
*
|
|
|
|
* Work item which can be used by the driver or helpers to execute the
|
|
|
|
* commit without blocking.
|
|
|
|
*/
|
|
|
|
struct work_struct commit_work;
|
|
|
|
};
|
|
|
|
|
2016-12-21 06:03:35 -07:00
|
|
|
void __drm_crtc_commit_free(struct kref *kref);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_crtc_commit_get - acquire a reference to the CRTC commit
|
|
|
|
* @commit: CRTC commit
|
|
|
|
*
|
|
|
|
* Increases the reference of @commit.
|
2017-09-04 04:48:36 -06:00
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* The pointer to @commit, with reference increased.
|
2016-12-21 06:03:35 -07:00
|
|
|
*/
|
2017-09-04 04:48:36 -06:00
|
|
|
static inline struct drm_crtc_commit *drm_crtc_commit_get(struct drm_crtc_commit *commit)
|
2016-06-08 06:19:00 -06:00
|
|
|
{
|
|
|
|
kref_get(&commit->ref);
|
2017-09-04 04:48:36 -06:00
|
|
|
return commit;
|
2016-06-08 06:19:00 -06:00
|
|
|
}
|
|
|
|
|
2016-12-21 06:03:35 -07:00
|
|
|
/**
|
|
|
|
* drm_crtc_commit_put - release a reference to the CRTC commmit
|
|
|
|
* @commit: CRTC commit
|
|
|
|
*
|
|
|
|
* This releases a reference to @commit which is freed after removing the
|
|
|
|
* final reference. No locking required and callable from any context.
|
|
|
|
*/
|
|
|
|
static inline void drm_crtc_commit_put(struct drm_crtc_commit *commit)
|
|
|
|
{
|
|
|
|
kref_put(&commit->ref, __drm_crtc_commit_free);
|
|
|
|
}
|
|
|
|
|
2014-07-25 13:30:38 -06:00
|
|
|
struct drm_atomic_state * __must_check
|
|
|
|
drm_atomic_state_alloc(struct drm_device *dev);
|
|
|
|
void drm_atomic_state_clear(struct drm_atomic_state *state);
|
2016-10-14 06:18:18 -06:00
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_atomic_state_get - acquire a reference to the atomic state
|
|
|
|
* @state: The atomic state
|
|
|
|
*
|
|
|
|
* Returns a new reference to the @state
|
|
|
|
*/
|
|
|
|
static inline struct drm_atomic_state *
|
|
|
|
drm_atomic_state_get(struct drm_atomic_state *state)
|
|
|
|
{
|
|
|
|
kref_get(&state->ref);
|
|
|
|
return state;
|
|
|
|
}
|
|
|
|
|
|
|
|
void __drm_atomic_state_free(struct kref *ref);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_atomic_state_put - release a reference to the atomic state
|
|
|
|
* @state: The atomic state
|
|
|
|
*
|
|
|
|
* This releases a reference to @state which is freed after removing the
|
|
|
|
* final reference. No locking required and callable from any context.
|
|
|
|
*/
|
|
|
|
static inline void drm_atomic_state_put(struct drm_atomic_state *state)
|
|
|
|
{
|
|
|
|
kref_put(&state->ref, __drm_atomic_state_free);
|
|
|
|
}
|
2015-05-18 02:06:40 -06:00
|
|
|
|
|
|
|
int __must_check
|
|
|
|
drm_atomic_state_init(struct drm_device *dev, struct drm_atomic_state *state);
|
|
|
|
void drm_atomic_state_default_clear(struct drm_atomic_state *state);
|
|
|
|
void drm_atomic_state_default_release(struct drm_atomic_state *state);
|
2014-07-25 13:30:38 -06:00
|
|
|
|
|
|
|
struct drm_crtc_state * __must_check
|
|
|
|
drm_atomic_get_crtc_state(struct drm_atomic_state *state,
|
|
|
|
struct drm_crtc *crtc);
|
|
|
|
struct drm_plane_state * __must_check
|
|
|
|
drm_atomic_get_plane_state(struct drm_atomic_state *state,
|
|
|
|
struct drm_plane *plane);
|
|
|
|
struct drm_connector_state * __must_check
|
|
|
|
drm_atomic_get_connector_state(struct drm_atomic_state *state,
|
|
|
|
struct drm_connector *connector);
|
2014-12-18 14:01:50 -07:00
|
|
|
|
2018-10-22 06:31:22 -06:00
|
|
|
void drm_atomic_private_obj_init(struct drm_device *dev,
|
|
|
|
struct drm_private_obj *obj,
|
2017-07-12 09:51:02 -06:00
|
|
|
struct drm_private_state *state,
|
|
|
|
const struct drm_private_state_funcs *funcs);
|
|
|
|
void drm_atomic_private_obj_fini(struct drm_private_obj *obj);
|
|
|
|
|
|
|
|
struct drm_private_state * __must_check
|
2017-04-20 23:51:30 -06:00
|
|
|
drm_atomic_get_private_obj_state(struct drm_atomic_state *state,
|
2017-07-12 09:51:02 -06:00
|
|
|
struct drm_private_obj *obj);
|
2019-01-22 04:05:41 -07:00
|
|
|
struct drm_private_state *
|
|
|
|
drm_atomic_get_old_private_obj_state(struct drm_atomic_state *state,
|
|
|
|
struct drm_private_obj *obj);
|
|
|
|
struct drm_private_state *
|
|
|
|
drm_atomic_get_new_private_obj_state(struct drm_atomic_state *state,
|
|
|
|
struct drm_private_obj *obj);
|
2017-04-20 23:51:30 -06:00
|
|
|
|
2019-06-11 14:51:43 -06:00
|
|
|
struct drm_connector *
|
|
|
|
drm_atomic_get_old_connector_for_encoder(struct drm_atomic_state *state,
|
|
|
|
struct drm_encoder *encoder);
|
|
|
|
struct drm_connector *
|
|
|
|
drm_atomic_get_new_connector_for_encoder(struct drm_atomic_state *state,
|
|
|
|
struct drm_encoder *encoder);
|
|
|
|
|
2015-05-13 02:37:25 -06:00
|
|
|
/**
|
2019-12-06 06:53:36 -07:00
|
|
|
* drm_atomic_get_existing_crtc_state - get CRTC state, if it exists
|
2015-05-13 02:37:25 -06:00
|
|
|
* @state: global atomic state object
|
2019-12-06 06:53:36 -07:00
|
|
|
* @crtc: CRTC to grab
|
2015-05-13 02:37:25 -06:00
|
|
|
*
|
2019-12-06 06:53:36 -07:00
|
|
|
* This function returns the CRTC state for the given CRTC, or NULL
|
|
|
|
* if the CRTC is not part of the global atomic state.
|
2017-02-16 07:47:08 -07:00
|
|
|
*
|
|
|
|
* This function is deprecated, @drm_atomic_get_old_crtc_state or
|
|
|
|
* @drm_atomic_get_new_crtc_state should be used instead.
|
2015-05-13 02:37:25 -06:00
|
|
|
*/
|
|
|
|
static inline struct drm_crtc_state *
|
|
|
|
drm_atomic_get_existing_crtc_state(struct drm_atomic_state *state,
|
|
|
|
struct drm_crtc *crtc)
|
|
|
|
{
|
2016-06-01 16:06:34 -06:00
|
|
|
return state->crtcs[drm_crtc_index(crtc)].state;
|
2015-05-13 02:37:25 -06:00
|
|
|
}
|
|
|
|
|
2017-02-16 07:47:08 -07:00
|
|
|
/**
|
2019-12-06 06:53:36 -07:00
|
|
|
* drm_atomic_get_old_crtc_state - get old CRTC state, if it exists
|
2017-02-16 07:47:08 -07:00
|
|
|
* @state: global atomic state object
|
2019-12-06 06:53:36 -07:00
|
|
|
* @crtc: CRTC to grab
|
2017-02-16 07:47:08 -07:00
|
|
|
*
|
2019-12-06 06:53:36 -07:00
|
|
|
* This function returns the old CRTC state for the given CRTC, or
|
|
|
|
* NULL if the CRTC is not part of the global atomic state.
|
2017-02-16 07:47:08 -07:00
|
|
|
*/
|
|
|
|
static inline struct drm_crtc_state *
|
|
|
|
drm_atomic_get_old_crtc_state(struct drm_atomic_state *state,
|
|
|
|
struct drm_crtc *crtc)
|
|
|
|
{
|
|
|
|
return state->crtcs[drm_crtc_index(crtc)].old_state;
|
|
|
|
}
|
|
|
|
/**
|
2019-12-06 06:53:36 -07:00
|
|
|
* drm_atomic_get_new_crtc_state - get new CRTC state, if it exists
|
2017-02-16 07:47:08 -07:00
|
|
|
* @state: global atomic state object
|
2019-12-06 06:53:36 -07:00
|
|
|
* @crtc: CRTC to grab
|
2017-02-16 07:47:08 -07:00
|
|
|
*
|
2019-12-06 06:53:36 -07:00
|
|
|
* This function returns the new CRTC state for the given CRTC, or
|
|
|
|
* NULL if the CRTC is not part of the global atomic state.
|
2017-02-16 07:47:08 -07:00
|
|
|
*/
|
|
|
|
static inline struct drm_crtc_state *
|
|
|
|
drm_atomic_get_new_crtc_state(struct drm_atomic_state *state,
|
|
|
|
struct drm_crtc *crtc)
|
|
|
|
{
|
|
|
|
return state->crtcs[drm_crtc_index(crtc)].new_state;
|
|
|
|
}
|
|
|
|
|
2015-05-13 02:37:25 -06:00
|
|
|
/**
|
|
|
|
* drm_atomic_get_existing_plane_state - get plane state, if it exists
|
|
|
|
* @state: global atomic state object
|
|
|
|
* @plane: plane to grab
|
|
|
|
*
|
|
|
|
* This function returns the plane state for the given plane, or NULL
|
|
|
|
* if the plane is not part of the global atomic state.
|
2017-02-16 07:47:08 -07:00
|
|
|
*
|
|
|
|
* This function is deprecated, @drm_atomic_get_old_plane_state or
|
|
|
|
* @drm_atomic_get_new_plane_state should be used instead.
|
2015-05-13 02:37:25 -06:00
|
|
|
*/
|
|
|
|
static inline struct drm_plane_state *
|
|
|
|
drm_atomic_get_existing_plane_state(struct drm_atomic_state *state,
|
|
|
|
struct drm_plane *plane)
|
|
|
|
{
|
2016-06-01 16:06:33 -06:00
|
|
|
return state->planes[drm_plane_index(plane)].state;
|
2015-05-13 02:37:25 -06:00
|
|
|
}
|
|
|
|
|
2017-02-16 07:47:08 -07:00
|
|
|
/**
|
|
|
|
* drm_atomic_get_old_plane_state - get plane state, if it exists
|
|
|
|
* @state: global atomic state object
|
|
|
|
* @plane: plane to grab
|
|
|
|
*
|
|
|
|
* This function returns the old plane state for the given plane, or
|
|
|
|
* NULL if the plane is not part of the global atomic state.
|
|
|
|
*/
|
|
|
|
static inline struct drm_plane_state *
|
|
|
|
drm_atomic_get_old_plane_state(struct drm_atomic_state *state,
|
|
|
|
struct drm_plane *plane)
|
|
|
|
{
|
|
|
|
return state->planes[drm_plane_index(plane)].old_state;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_atomic_get_new_plane_state - get plane state, if it exists
|
|
|
|
* @state: global atomic state object
|
|
|
|
* @plane: plane to grab
|
|
|
|
*
|
|
|
|
* This function returns the new plane state for the given plane, or
|
|
|
|
* NULL if the plane is not part of the global atomic state.
|
|
|
|
*/
|
|
|
|
static inline struct drm_plane_state *
|
|
|
|
drm_atomic_get_new_plane_state(struct drm_atomic_state *state,
|
|
|
|
struct drm_plane *plane)
|
|
|
|
{
|
|
|
|
return state->planes[drm_plane_index(plane)].new_state;
|
|
|
|
}
|
|
|
|
|
2015-05-13 02:37:25 -06:00
|
|
|
/**
|
|
|
|
* drm_atomic_get_existing_connector_state - get connector state, if it exists
|
|
|
|
* @state: global atomic state object
|
|
|
|
* @connector: connector to grab
|
|
|
|
*
|
|
|
|
* This function returns the connector state for the given connector,
|
|
|
|
* or NULL if the connector is not part of the global atomic state.
|
2017-02-16 07:47:08 -07:00
|
|
|
*
|
|
|
|
* This function is deprecated, @drm_atomic_get_old_connector_state or
|
|
|
|
* @drm_atomic_get_new_connector_state should be used instead.
|
2015-05-13 02:37:25 -06:00
|
|
|
*/
|
|
|
|
static inline struct drm_connector_state *
|
|
|
|
drm_atomic_get_existing_connector_state(struct drm_atomic_state *state,
|
|
|
|
struct drm_connector *connector)
|
|
|
|
{
|
|
|
|
int index = drm_connector_index(connector);
|
|
|
|
|
|
|
|
if (index >= state->num_connector)
|
|
|
|
return NULL;
|
|
|
|
|
2016-06-01 16:06:32 -06:00
|
|
|
return state->connectors[index].state;
|
2015-05-13 02:37:25 -06:00
|
|
|
}
|
|
|
|
|
2017-02-16 07:47:08 -07:00
|
|
|
/**
|
|
|
|
* drm_atomic_get_old_connector_state - get connector state, if it exists
|
|
|
|
* @state: global atomic state object
|
|
|
|
* @connector: connector to grab
|
|
|
|
*
|
|
|
|
* This function returns the old connector state for the given connector,
|
|
|
|
* or NULL if the connector is not part of the global atomic state.
|
|
|
|
*/
|
|
|
|
static inline struct drm_connector_state *
|
|
|
|
drm_atomic_get_old_connector_state(struct drm_atomic_state *state,
|
|
|
|
struct drm_connector *connector)
|
|
|
|
{
|
|
|
|
int index = drm_connector_index(connector);
|
|
|
|
|
|
|
|
if (index >= state->num_connector)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return state->connectors[index].old_state;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_atomic_get_new_connector_state - get connector state, if it exists
|
|
|
|
* @state: global atomic state object
|
|
|
|
* @connector: connector to grab
|
|
|
|
*
|
|
|
|
* This function returns the new connector state for the given connector,
|
|
|
|
* or NULL if the connector is not part of the global atomic state.
|
|
|
|
*/
|
|
|
|
static inline struct drm_connector_state *
|
|
|
|
drm_atomic_get_new_connector_state(struct drm_atomic_state *state,
|
|
|
|
struct drm_connector *connector)
|
|
|
|
{
|
|
|
|
int index = drm_connector_index(connector);
|
|
|
|
|
|
|
|
if (index >= state->num_connector)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return state->connectors[index].new_state;
|
|
|
|
}
|
|
|
|
|
2016-06-02 08:21:44 -06:00
|
|
|
/**
|
|
|
|
* __drm_atomic_get_current_plane_state - get current plane state
|
|
|
|
* @state: global atomic state object
|
|
|
|
* @plane: plane to grab
|
|
|
|
*
|
|
|
|
* This function returns the plane state for the given plane, either from
|
|
|
|
* @state, or if the plane isn't part of the atomic state update, from @plane.
|
|
|
|
* This is useful in atomic check callbacks, when drivers need to peek at, but
|
|
|
|
* not change, state of other planes, since it avoids threading an error code
|
|
|
|
* back up the call chain.
|
|
|
|
*
|
|
|
|
* WARNING:
|
|
|
|
*
|
|
|
|
* Note that this function is in general unsafe since it doesn't check for the
|
|
|
|
* required locking for access state structures. Drivers must ensure that it is
|
2016-06-02 09:39:14 -06:00
|
|
|
* safe to access the returned state structure through other means. One common
|
2016-06-02 08:21:44 -06:00
|
|
|
* example is when planes are fixed to a single CRTC, and the driver knows that
|
2016-06-02 09:39:14 -06:00
|
|
|
* the CRTC lock is held already. In that case holding the CRTC lock gives a
|
2016-06-02 08:21:44 -06:00
|
|
|
* read-lock on all planes connected to that CRTC. But if planes can be
|
|
|
|
* reassigned things get more tricky. In that case it's better to use
|
|
|
|
* drm_atomic_get_plane_state and wire up full error handling.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
*
|
|
|
|
* Read-only pointer to the current plane state.
|
|
|
|
*/
|
|
|
|
static inline const struct drm_plane_state *
|
|
|
|
__drm_atomic_get_current_plane_state(struct drm_atomic_state *state,
|
|
|
|
struct drm_plane *plane)
|
|
|
|
{
|
2016-06-01 16:06:33 -06:00
|
|
|
if (state->planes[drm_plane_index(plane)].state)
|
|
|
|
return state->planes[drm_plane_index(plane)].state;
|
2016-06-02 08:21:44 -06:00
|
|
|
|
|
|
|
return plane->state;
|
|
|
|
}
|
|
|
|
|
2020-01-28 06:55:03 -07:00
|
|
|
int __must_check
|
|
|
|
drm_atomic_add_encoder_bridges(struct drm_atomic_state *state,
|
|
|
|
struct drm_encoder *encoder);
|
2014-07-25 13:30:38 -06:00
|
|
|
int __must_check
|
|
|
|
drm_atomic_add_affected_connectors(struct drm_atomic_state *state,
|
|
|
|
struct drm_crtc *crtc);
|
2015-05-19 08:41:02 -06:00
|
|
|
int __must_check
|
|
|
|
drm_atomic_add_affected_planes(struct drm_atomic_state *state,
|
|
|
|
struct drm_crtc *crtc);
|
|
|
|
|
2014-07-25 13:30:38 -06:00
|
|
|
int __must_check drm_atomic_check_only(struct drm_atomic_state *state);
|
|
|
|
int __must_check drm_atomic_commit(struct drm_atomic_state *state);
|
2016-04-26 08:11:35 -06:00
|
|
|
int __must_check drm_atomic_nonblocking_commit(struct drm_atomic_state *state);
|
2014-07-25 13:30:38 -06:00
|
|
|
|
2016-11-05 09:08:10 -06:00
|
|
|
void drm_state_dump(struct drm_device *dev, struct drm_printer *p);
|
|
|
|
|
2017-03-28 09:53:49 -06:00
|
|
|
/**
|
|
|
|
* for_each_oldnew_connector_in_state - iterate over all connectors in an atomic update
|
|
|
|
* @__state: &struct drm_atomic_state pointer
|
|
|
|
* @connector: &struct drm_connector iteration cursor
|
|
|
|
* @old_connector_state: &struct drm_connector_state iteration cursor for the
|
|
|
|
* old state
|
|
|
|
* @new_connector_state: &struct drm_connector_state iteration cursor for the
|
|
|
|
* new state
|
|
|
|
* @__i: int iteration cursor, for macro-internal use
|
|
|
|
*
|
|
|
|
* This iterates over all connectors in an atomic update, tracking both old and
|
|
|
|
* new state. This is useful in places where the state delta needs to be
|
|
|
|
* considered, for example in atomic check functions.
|
|
|
|
*/
|
2017-01-16 02:37:38 -07:00
|
|
|
#define for_each_oldnew_connector_in_state(__state, connector, old_connector_state, new_connector_state, __i) \
|
|
|
|
for ((__i) = 0; \
|
2017-09-27 02:35:32 -06:00
|
|
|
(__i) < (__state)->num_connector; \
|
|
|
|
(__i)++) \
|
|
|
|
for_each_if ((__state)->connectors[__i].ptr && \
|
|
|
|
((connector) = (__state)->connectors[__i].ptr, \
|
2019-10-08 06:42:54 -06:00
|
|
|
(void)(connector) /* Only to avoid unused-but-set-variable warning */, \
|
2017-09-27 02:35:32 -06:00
|
|
|
(old_connector_state) = (__state)->connectors[__i].old_state, \
|
|
|
|
(new_connector_state) = (__state)->connectors[__i].new_state, 1))
|
2017-01-16 02:37:38 -07:00
|
|
|
|
2017-03-28 09:53:49 -06:00
|
|
|
/**
|
|
|
|
* for_each_old_connector_in_state - iterate over all connectors in an atomic update
|
|
|
|
* @__state: &struct drm_atomic_state pointer
|
|
|
|
* @connector: &struct drm_connector iteration cursor
|
|
|
|
* @old_connector_state: &struct drm_connector_state iteration cursor for the
|
|
|
|
* old state
|
|
|
|
* @__i: int iteration cursor, for macro-internal use
|
|
|
|
*
|
|
|
|
* This iterates over all connectors in an atomic update, tracking only the old
|
|
|
|
* state. This is useful in disable functions, where we need the old state the
|
|
|
|
* hardware is still in.
|
|
|
|
*/
|
2017-01-16 02:37:38 -07:00
|
|
|
#define for_each_old_connector_in_state(__state, connector, old_connector_state, __i) \
|
|
|
|
for ((__i) = 0; \
|
2017-09-27 02:35:32 -06:00
|
|
|
(__i) < (__state)->num_connector; \
|
|
|
|
(__i)++) \
|
|
|
|
for_each_if ((__state)->connectors[__i].ptr && \
|
|
|
|
((connector) = (__state)->connectors[__i].ptr, \
|
2019-10-08 06:42:54 -06:00
|
|
|
(void)(connector) /* Only to avoid unused-but-set-variable warning */, \
|
2017-09-27 02:35:32 -06:00
|
|
|
(old_connector_state) = (__state)->connectors[__i].old_state, 1))
|
2017-01-16 02:37:38 -07:00
|
|
|
|
2017-03-28 09:53:49 -06:00
|
|
|
/**
|
|
|
|
* for_each_new_connector_in_state - iterate over all connectors in an atomic update
|
|
|
|
* @__state: &struct drm_atomic_state pointer
|
|
|
|
* @connector: &struct drm_connector iteration cursor
|
|
|
|
* @new_connector_state: &struct drm_connector_state iteration cursor for the
|
|
|
|
* new state
|
|
|
|
* @__i: int iteration cursor, for macro-internal use
|
|
|
|
*
|
|
|
|
* This iterates over all connectors in an atomic update, tracking only the new
|
|
|
|
* state. This is useful in enable functions, where we need the new state the
|
|
|
|
* hardware should be in when the atomic commit operation has completed.
|
|
|
|
*/
|
2017-01-16 02:37:38 -07:00
|
|
|
#define for_each_new_connector_in_state(__state, connector, new_connector_state, __i) \
|
|
|
|
for ((__i) = 0; \
|
2017-09-27 02:35:32 -06:00
|
|
|
(__i) < (__state)->num_connector; \
|
|
|
|
(__i)++) \
|
|
|
|
for_each_if ((__state)->connectors[__i].ptr && \
|
|
|
|
((connector) = (__state)->connectors[__i].ptr, \
|
2019-10-08 06:42:54 -06:00
|
|
|
(void)(connector) /* Only to avoid unused-but-set-variable warning */, \
|
|
|
|
(new_connector_state) = (__state)->connectors[__i].new_state, \
|
|
|
|
(void)(new_connector_state) /* Only to avoid unused-but-set-variable warning */, 1))
|
2017-01-16 02:37:38 -07:00
|
|
|
|
2017-03-28 09:53:49 -06:00
|
|
|
/**
|
|
|
|
* for_each_oldnew_crtc_in_state - iterate over all CRTCs in an atomic update
|
|
|
|
* @__state: &struct drm_atomic_state pointer
|
|
|
|
* @crtc: &struct drm_crtc iteration cursor
|
|
|
|
* @old_crtc_state: &struct drm_crtc_state iteration cursor for the old state
|
|
|
|
* @new_crtc_state: &struct drm_crtc_state iteration cursor for the new state
|
|
|
|
* @__i: int iteration cursor, for macro-internal use
|
|
|
|
*
|
|
|
|
* This iterates over all CRTCs in an atomic update, tracking both old and
|
|
|
|
* new state. This is useful in places where the state delta needs to be
|
|
|
|
* considered, for example in atomic check functions.
|
|
|
|
*/
|
2017-01-16 02:37:38 -07:00
|
|
|
#define for_each_oldnew_crtc_in_state(__state, crtc, old_crtc_state, new_crtc_state, __i) \
|
|
|
|
for ((__i) = 0; \
|
2017-09-27 02:35:32 -06:00
|
|
|
(__i) < (__state)->dev->mode_config.num_crtc; \
|
2017-01-16 02:37:38 -07:00
|
|
|
(__i)++) \
|
2017-09-27 02:35:32 -06:00
|
|
|
for_each_if ((__state)->crtcs[__i].ptr && \
|
|
|
|
((crtc) = (__state)->crtcs[__i].ptr, \
|
2019-10-08 06:42:54 -06:00
|
|
|
(void)(crtc) /* Only to avoid unused-but-set-variable warning */, \
|
2017-09-27 02:35:32 -06:00
|
|
|
(old_crtc_state) = (__state)->crtcs[__i].old_state, \
|
2019-10-08 06:42:54 -06:00
|
|
|
(void)(old_crtc_state) /* Only to avoid unused-but-set-variable warning */, \
|
2017-09-27 02:35:32 -06:00
|
|
|
(new_crtc_state) = (__state)->crtcs[__i].new_state, 1))
|
2017-01-16 02:37:38 -07:00
|
|
|
|
2017-03-28 09:53:49 -06:00
|
|
|
/**
|
|
|
|
* for_each_old_crtc_in_state - iterate over all CRTCs in an atomic update
|
|
|
|
* @__state: &struct drm_atomic_state pointer
|
|
|
|
* @crtc: &struct drm_crtc iteration cursor
|
|
|
|
* @old_crtc_state: &struct drm_crtc_state iteration cursor for the old state
|
|
|
|
* @__i: int iteration cursor, for macro-internal use
|
|
|
|
*
|
|
|
|
* This iterates over all CRTCs in an atomic update, tracking only the old
|
|
|
|
* state. This is useful in disable functions, where we need the old state the
|
|
|
|
* hardware is still in.
|
|
|
|
*/
|
2017-01-16 02:37:38 -07:00
|
|
|
#define for_each_old_crtc_in_state(__state, crtc, old_crtc_state, __i) \
|
|
|
|
for ((__i) = 0; \
|
2017-09-27 02:35:32 -06:00
|
|
|
(__i) < (__state)->dev->mode_config.num_crtc; \
|
2017-01-16 02:37:38 -07:00
|
|
|
(__i)++) \
|
2017-09-27 02:35:32 -06:00
|
|
|
for_each_if ((__state)->crtcs[__i].ptr && \
|
|
|
|
((crtc) = (__state)->crtcs[__i].ptr, \
|
|
|
|
(old_crtc_state) = (__state)->crtcs[__i].old_state, 1))
|
2017-01-16 02:37:38 -07:00
|
|
|
|
2017-03-28 09:53:49 -06:00
|
|
|
/**
|
|
|
|
* for_each_new_crtc_in_state - iterate over all CRTCs in an atomic update
|
|
|
|
* @__state: &struct drm_atomic_state pointer
|
|
|
|
* @crtc: &struct drm_crtc iteration cursor
|
|
|
|
* @new_crtc_state: &struct drm_crtc_state iteration cursor for the new state
|
|
|
|
* @__i: int iteration cursor, for macro-internal use
|
|
|
|
*
|
|
|
|
* This iterates over all CRTCs in an atomic update, tracking only the new
|
|
|
|
* state. This is useful in enable functions, where we need the new state the
|
|
|
|
* hardware should be in when the atomic commit operation has completed.
|
|
|
|
*/
|
2017-01-16 02:37:38 -07:00
|
|
|
#define for_each_new_crtc_in_state(__state, crtc, new_crtc_state, __i) \
|
|
|
|
for ((__i) = 0; \
|
2017-09-27 02:35:32 -06:00
|
|
|
(__i) < (__state)->dev->mode_config.num_crtc; \
|
2017-01-16 02:37:38 -07:00
|
|
|
(__i)++) \
|
2017-09-27 02:35:32 -06:00
|
|
|
for_each_if ((__state)->crtcs[__i].ptr && \
|
|
|
|
((crtc) = (__state)->crtcs[__i].ptr, \
|
2019-10-08 06:42:54 -06:00
|
|
|
(void)(crtc) /* Only to avoid unused-but-set-variable warning */, \
|
|
|
|
(new_crtc_state) = (__state)->crtcs[__i].new_state, \
|
|
|
|
(void)(new_crtc_state) /* Only to avoid unused-but-set-variable warning */, 1))
|
2017-01-16 02:37:38 -07:00
|
|
|
|
2017-03-28 09:53:49 -06:00
|
|
|
/**
|
|
|
|
* for_each_oldnew_plane_in_state - iterate over all planes in an atomic update
|
|
|
|
* @__state: &struct drm_atomic_state pointer
|
|
|
|
* @plane: &struct drm_plane iteration cursor
|
|
|
|
* @old_plane_state: &struct drm_plane_state iteration cursor for the old state
|
|
|
|
* @new_plane_state: &struct drm_plane_state iteration cursor for the new state
|
|
|
|
* @__i: int iteration cursor, for macro-internal use
|
|
|
|
*
|
|
|
|
* This iterates over all planes in an atomic update, tracking both old and
|
|
|
|
* new state. This is useful in places where the state delta needs to be
|
|
|
|
* considered, for example in atomic check functions.
|
|
|
|
*/
|
2017-01-16 02:37:38 -07:00
|
|
|
#define for_each_oldnew_plane_in_state(__state, plane, old_plane_state, new_plane_state, __i) \
|
|
|
|
for ((__i) = 0; \
|
2017-09-27 02:35:32 -06:00
|
|
|
(__i) < (__state)->dev->mode_config.num_total_plane; \
|
2017-01-16 02:37:38 -07:00
|
|
|
(__i)++) \
|
2017-09-27 02:35:32 -06:00
|
|
|
for_each_if ((__state)->planes[__i].ptr && \
|
|
|
|
((plane) = (__state)->planes[__i].ptr, \
|
2019-10-08 06:42:54 -06:00
|
|
|
(void)(plane) /* Only to avoid unused-but-set-variable warning */, \
|
2017-09-27 02:35:32 -06:00
|
|
|
(old_plane_state) = (__state)->planes[__i].old_state,\
|
|
|
|
(new_plane_state) = (__state)->planes[__i].new_state, 1))
|
2017-01-16 02:37:38 -07:00
|
|
|
|
2018-03-06 20:10:03 -07:00
|
|
|
/**
|
|
|
|
* for_each_oldnew_plane_in_state_reverse - iterate over all planes in an atomic
|
|
|
|
* update in reverse order
|
|
|
|
* @__state: &struct drm_atomic_state pointer
|
|
|
|
* @plane: &struct drm_plane iteration cursor
|
|
|
|
* @old_plane_state: &struct drm_plane_state iteration cursor for the old state
|
|
|
|
* @new_plane_state: &struct drm_plane_state iteration cursor for the new state
|
|
|
|
* @__i: int iteration cursor, for macro-internal use
|
|
|
|
*
|
|
|
|
* This iterates over all planes in an atomic update in reverse order,
|
|
|
|
* tracking both old and new state. This is useful in places where the
|
|
|
|
* state delta needs to be considered, for example in atomic check functions.
|
|
|
|
*/
|
|
|
|
#define for_each_oldnew_plane_in_state_reverse(__state, plane, old_plane_state, new_plane_state, __i) \
|
|
|
|
for ((__i) = ((__state)->dev->mode_config.num_total_plane - 1); \
|
|
|
|
(__i) >= 0; \
|
|
|
|
(__i)--) \
|
|
|
|
for_each_if ((__state)->planes[__i].ptr && \
|
|
|
|
((plane) = (__state)->planes[__i].ptr, \
|
|
|
|
(old_plane_state) = (__state)->planes[__i].old_state,\
|
|
|
|
(new_plane_state) = (__state)->planes[__i].new_state, 1))
|
|
|
|
|
2017-03-28 09:53:49 -06:00
|
|
|
/**
|
|
|
|
* for_each_old_plane_in_state - iterate over all planes in an atomic update
|
|
|
|
* @__state: &struct drm_atomic_state pointer
|
|
|
|
* @plane: &struct drm_plane iteration cursor
|
|
|
|
* @old_plane_state: &struct drm_plane_state iteration cursor for the old state
|
|
|
|
* @__i: int iteration cursor, for macro-internal use
|
|
|
|
*
|
|
|
|
* This iterates over all planes in an atomic update, tracking only the old
|
|
|
|
* state. This is useful in disable functions, where we need the old state the
|
|
|
|
* hardware is still in.
|
|
|
|
*/
|
2017-01-16 02:37:38 -07:00
|
|
|
#define for_each_old_plane_in_state(__state, plane, old_plane_state, __i) \
|
|
|
|
for ((__i) = 0; \
|
2017-09-27 02:35:32 -06:00
|
|
|
(__i) < (__state)->dev->mode_config.num_total_plane; \
|
2017-01-16 02:37:38 -07:00
|
|
|
(__i)++) \
|
2017-09-27 02:35:32 -06:00
|
|
|
for_each_if ((__state)->planes[__i].ptr && \
|
|
|
|
((plane) = (__state)->planes[__i].ptr, \
|
|
|
|
(old_plane_state) = (__state)->planes[__i].old_state, 1))
|
2017-03-28 09:53:49 -06:00
|
|
|
/**
|
|
|
|
* for_each_new_plane_in_state - iterate over all planes in an atomic update
|
|
|
|
* @__state: &struct drm_atomic_state pointer
|
|
|
|
* @plane: &struct drm_plane iteration cursor
|
|
|
|
* @new_plane_state: &struct drm_plane_state iteration cursor for the new state
|
|
|
|
* @__i: int iteration cursor, for macro-internal use
|
|
|
|
*
|
|
|
|
* This iterates over all planes in an atomic update, tracking only the new
|
|
|
|
* state. This is useful in enable functions, where we need the new state the
|
|
|
|
* hardware should be in when the atomic commit operation has completed.
|
|
|
|
*/
|
2017-01-16 02:37:38 -07:00
|
|
|
#define for_each_new_plane_in_state(__state, plane, new_plane_state, __i) \
|
|
|
|
for ((__i) = 0; \
|
2017-09-27 02:35:32 -06:00
|
|
|
(__i) < (__state)->dev->mode_config.num_total_plane; \
|
2017-01-16 02:37:38 -07:00
|
|
|
(__i)++) \
|
2017-09-27 02:35:32 -06:00
|
|
|
for_each_if ((__state)->planes[__i].ptr && \
|
|
|
|
((plane) = (__state)->planes[__i].ptr, \
|
2019-10-08 06:42:54 -06:00
|
|
|
(void)(plane) /* Only to avoid unused-but-set-variable warning */, \
|
|
|
|
(new_plane_state) = (__state)->planes[__i].new_state, \
|
|
|
|
(void)(new_plane_state) /* Only to avoid unused-but-set-variable warning */, 1))
|
2017-01-16 02:37:38 -07:00
|
|
|
|
2017-04-20 23:51:30 -06:00
|
|
|
/**
|
2017-07-12 09:51:02 -06:00
|
|
|
* for_each_oldnew_private_obj_in_state - iterate over all private objects in an atomic update
|
2017-04-20 23:51:30 -06:00
|
|
|
* @__state: &struct drm_atomic_state pointer
|
2017-07-12 09:51:02 -06:00
|
|
|
* @obj: &struct drm_private_obj iteration cursor
|
|
|
|
* @old_obj_state: &struct drm_private_state iteration cursor for the old state
|
|
|
|
* @new_obj_state: &struct drm_private_state iteration cursor for the new state
|
2017-04-20 23:51:30 -06:00
|
|
|
* @__i: int iteration cursor, for macro-internal use
|
|
|
|
*
|
2017-07-12 09:51:02 -06:00
|
|
|
* This iterates over all private objects in an atomic update, tracking both
|
|
|
|
* old and new state. This is useful in places where the state delta needs
|
|
|
|
* to be considered, for example in atomic check functions.
|
2017-04-20 23:51:30 -06:00
|
|
|
*/
|
2017-07-12 09:51:02 -06:00
|
|
|
#define for_each_oldnew_private_obj_in_state(__state, obj, old_obj_state, new_obj_state, __i) \
|
|
|
|
for ((__i) = 0; \
|
|
|
|
(__i) < (__state)->num_private_objs && \
|
|
|
|
((obj) = (__state)->private_objs[__i].ptr, \
|
|
|
|
(old_obj_state) = (__state)->private_objs[__i].old_state, \
|
|
|
|
(new_obj_state) = (__state)->private_objs[__i].new_state, 1); \
|
2017-09-27 02:35:31 -06:00
|
|
|
(__i)++)
|
2017-07-12 09:51:02 -06:00
|
|
|
|
|
|
|
/**
|
|
|
|
* for_each_old_private_obj_in_state - iterate over all private objects in an atomic update
|
|
|
|
* @__state: &struct drm_atomic_state pointer
|
|
|
|
* @obj: &struct drm_private_obj iteration cursor
|
|
|
|
* @old_obj_state: &struct drm_private_state iteration cursor for the old state
|
|
|
|
* @__i: int iteration cursor, for macro-internal use
|
|
|
|
*
|
|
|
|
* This iterates over all private objects in an atomic update, tracking only
|
|
|
|
* the old state. This is useful in disable functions, where we need the old
|
|
|
|
* state the hardware is still in.
|
|
|
|
*/
|
|
|
|
#define for_each_old_private_obj_in_state(__state, obj, old_obj_state, __i) \
|
|
|
|
for ((__i) = 0; \
|
|
|
|
(__i) < (__state)->num_private_objs && \
|
|
|
|
((obj) = (__state)->private_objs[__i].ptr, \
|
|
|
|
(old_obj_state) = (__state)->private_objs[__i].old_state, 1); \
|
2017-09-27 02:35:31 -06:00
|
|
|
(__i)++)
|
2017-04-20 23:51:30 -06:00
|
|
|
|
|
|
|
/**
|
2017-07-12 09:51:02 -06:00
|
|
|
* for_each_new_private_obj_in_state - iterate over all private objects in an atomic update
|
2017-04-20 23:51:30 -06:00
|
|
|
* @__state: &struct drm_atomic_state pointer
|
2017-07-12 09:51:02 -06:00
|
|
|
* @obj: &struct drm_private_obj iteration cursor
|
|
|
|
* @new_obj_state: &struct drm_private_state iteration cursor for the new state
|
2017-04-20 23:51:30 -06:00
|
|
|
* @__i: int iteration cursor, for macro-internal use
|
|
|
|
*
|
2017-07-12 09:51:02 -06:00
|
|
|
* This iterates over all private objects in an atomic update, tracking only
|
|
|
|
* the new state. This is useful in enable functions, where we need the new state the
|
|
|
|
* hardware should be in when the atomic commit operation has completed.
|
2017-04-20 23:51:30 -06:00
|
|
|
*/
|
2017-07-12 09:51:02 -06:00
|
|
|
#define for_each_new_private_obj_in_state(__state, obj, new_obj_state, __i) \
|
|
|
|
for ((__i) = 0; \
|
|
|
|
(__i) < (__state)->num_private_objs && \
|
|
|
|
((obj) = (__state)->private_objs[__i].ptr, \
|
|
|
|
(new_obj_state) = (__state)->private_objs[__i].new_state, 1); \
|
2017-09-27 02:35:31 -06:00
|
|
|
(__i)++)
|
2017-04-20 23:51:30 -06:00
|
|
|
|
2016-06-08 06:18:59 -06:00
|
|
|
/**
|
|
|
|
* drm_atomic_crtc_needs_modeset - compute combined modeset need
|
|
|
|
* @state: &drm_crtc_state for the CRTC
|
|
|
|
*
|
2016-12-29 13:48:26 -07:00
|
|
|
* To give drivers flexibility &struct drm_crtc_state has 3 booleans to track
|
2016-06-08 06:18:59 -06:00
|
|
|
* whether the state CRTC changed enough to need a full modeset cycle:
|
2017-07-31 03:13:43 -06:00
|
|
|
* mode_changed, active_changed and connectors_changed. This helper simply
|
2016-06-08 06:18:59 -06:00
|
|
|
* combines these three to compute the overall need for a modeset for @state.
|
2016-10-13 03:47:08 -06:00
|
|
|
*
|
|
|
|
* The atomic helper code sets these booleans, but drivers can and should
|
|
|
|
* change them appropriately to accurately represent whether a modeset is
|
|
|
|
* really needed. In general, drivers should avoid full modesets whenever
|
|
|
|
* possible.
|
|
|
|
*
|
|
|
|
* For example if the CRTC mode has changed, and the hardware is able to enact
|
|
|
|
* the requested mode change without going through a full modeset, the driver
|
2017-01-24 23:26:45 -07:00
|
|
|
* should clear mode_changed in its &drm_mode_config_funcs.atomic_check
|
|
|
|
* implementation.
|
2016-06-08 06:18:59 -06:00
|
|
|
*/
|
2015-06-18 01:58:55 -06:00
|
|
|
static inline bool
|
2016-11-24 10:47:02 -07:00
|
|
|
drm_atomic_crtc_needs_modeset(const struct drm_crtc_state *state)
|
2015-06-18 01:58:55 -06:00
|
|
|
{
|
2015-07-21 05:28:57 -06:00
|
|
|
return state->mode_changed || state->active_changed ||
|
|
|
|
state->connectors_changed;
|
2015-06-18 01:58:55 -06:00
|
|
|
}
|
|
|
|
|
2019-06-12 08:50:19 -06:00
|
|
|
/**
|
2019-12-06 06:53:36 -07:00
|
|
|
* drm_atomic_crtc_effectively_active - compute whether CRTC is actually active
|
2019-06-12 08:50:19 -06:00
|
|
|
* @state: &drm_crtc_state for the CRTC
|
|
|
|
*
|
|
|
|
* When in self refresh mode, the crtc_state->active value will be false, since
|
2019-12-06 06:53:36 -07:00
|
|
|
* the CRTC is off. However in some cases we're interested in whether the CRTC
|
2019-06-12 08:50:19 -06:00
|
|
|
* is active, or effectively active (ie: it's connected to an active display).
|
|
|
|
* In these cases, use this function instead of just checking active.
|
|
|
|
*/
|
|
|
|
static inline bool
|
|
|
|
drm_atomic_crtc_effectively_active(const struct drm_crtc_state *state)
|
|
|
|
{
|
|
|
|
return state->active || state->self_refresh_active;
|
|
|
|
}
|
|
|
|
|
drm/bridge: Add the necessary bits to support bus format negotiation
drm_bridge_state is extended to describe the input and output bus
configurations. These bus configurations are exposed through the
drm_bus_cfg struct which encodes the configuration of a physical
bus between two components in an output pipeline, usually between
two bridges, an encoder and a bridge, or a bridge and a connector.
The bus configuration is stored in drm_bridge_state separately for
the input and output buses, as seen from the point of view of each
bridge. The bus configuration of a bridge output is usually identical
to the configuration of the next bridge's input, but may differ if
the signals are modified between the two bridges, for instance by an
inverter on the board. The input and output configurations of a
bridge may differ if the bridge modifies the signals internally,
for instance by performing format conversion, or*modifying signals
polarities.
Bus format negotiation is automated by the core, drivers just have
to implement the ->atomic_get_{output,input}_bus_fmts() hooks if they
want to take part to this negotiation. Negotiation happens in reverse
order, starting from the last element of the chain (the one directly
connected to the display) up to the first element of the chain (the one
connected to the encoder).
During this negotiation all supported formats are tested until we find
one that works, meaning that the formats array should be in decreasing
preference order (assuming the driver has a preference order).
Note that the bus format negotiation works even if some elements in the
chain don't implement the ->atomic_get_{output,input}_bus_fmts() hooks.
In that case, the core advertises only MEDIA_BUS_FMT_FIXED and lets
the previous bridge element decide what to do (most of the time, bridge
drivers will pick a default bus format or extract this piece of
information from somewhere else, like a FW property).
v10:
* Add changelog to the commit message
v9:
* No changes
v8:
* Fix a test in drm_atomic_bridge_chain_select_bus_fmts() (Reported by
Jonas)
v7:
* Adapt the code to deal with the fact that not all bridges in the
chain have a bridge state
v5 -> v6:
* No changes
v4:
* Enhance the doc
* Fix typos
* Rename some parameters/fields
* Reword the commit message
v3:
* Fix the commit message (Reported by Laurent)
* Document the fact that bus formats should not be directly modified by
drivers (Suggested by Laurent)
* Document the fact that format order matters (Suggested by Laurent)
* Propagate bus flags by default
* Document the fact that drivers can tweak bus flags if needed
* Let ->atomic_get_{output,input}_bus_fmts() allocate the bus format
array (Suggested by Laurent)
* Add a drm_atomic_helper_bridge_propagate_bus_fmt()
* Mandate that bridge drivers return accurate input_fmts even if they
are known to be the first element in the bridge chain
v2:
* Rework things to support more complex use cases
Signed-off-by: Boris Brezillon <boris.brezillon@collabora.com>
Signed-off-by: Neil Armstrong <narmstrong@baylibre.com>
[narmstrong: fixed doc in include/drm/drm_bridge.h:69 fmt->format]
Reviewed-by: Jernej Skrabec <jernej.skrabec@siol.net>
Tested-by: Jonas Karlman <jonas@kwiboo.se>
Link: https://patchwork.freedesktop.org/patch/msgid/20200128135514.108171-7-boris.brezillon@collabora.com
2020-01-28 06:55:08 -07:00
|
|
|
/**
|
|
|
|
* struct drm_bus_cfg - bus configuration
|
|
|
|
*
|
|
|
|
* This structure stores the configuration of a physical bus between two
|
|
|
|
* components in an output pipeline, usually between two bridges, an encoder
|
|
|
|
* and a bridge, or a bridge and a connector.
|
|
|
|
*
|
|
|
|
* The bus configuration is stored in &drm_bridge_state separately for the
|
|
|
|
* input and output buses, as seen from the point of view of each bridge. The
|
|
|
|
* bus configuration of a bridge output is usually identical to the
|
|
|
|
* configuration of the next bridge's input, but may differ if the signals are
|
|
|
|
* modified between the two bridges, for instance by an inverter on the board.
|
|
|
|
* The input and output configurations of a bridge may differ if the bridge
|
|
|
|
* modifies the signals internally, for instance by performing format
|
|
|
|
* conversion, or modifying signals polarities.
|
|
|
|
*/
|
|
|
|
struct drm_bus_cfg {
|
|
|
|
/**
|
|
|
|
* @format: format used on this bus (one of the MEDIA_BUS_FMT_* format)
|
|
|
|
*
|
|
|
|
* This field should not be directly modified by drivers
|
2020-02-18 08:15:03 -07:00
|
|
|
* (drm_atomic_bridge_chain_select_bus_fmts() takes care of the bus
|
drm/bridge: Add the necessary bits to support bus format negotiation
drm_bridge_state is extended to describe the input and output bus
configurations. These bus configurations are exposed through the
drm_bus_cfg struct which encodes the configuration of a physical
bus between two components in an output pipeline, usually between
two bridges, an encoder and a bridge, or a bridge and a connector.
The bus configuration is stored in drm_bridge_state separately for
the input and output buses, as seen from the point of view of each
bridge. The bus configuration of a bridge output is usually identical
to the configuration of the next bridge's input, but may differ if
the signals are modified between the two bridges, for instance by an
inverter on the board. The input and output configurations of a
bridge may differ if the bridge modifies the signals internally,
for instance by performing format conversion, or*modifying signals
polarities.
Bus format negotiation is automated by the core, drivers just have
to implement the ->atomic_get_{output,input}_bus_fmts() hooks if they
want to take part to this negotiation. Negotiation happens in reverse
order, starting from the last element of the chain (the one directly
connected to the display) up to the first element of the chain (the one
connected to the encoder).
During this negotiation all supported formats are tested until we find
one that works, meaning that the formats array should be in decreasing
preference order (assuming the driver has a preference order).
Note that the bus format negotiation works even if some elements in the
chain don't implement the ->atomic_get_{output,input}_bus_fmts() hooks.
In that case, the core advertises only MEDIA_BUS_FMT_FIXED and lets
the previous bridge element decide what to do (most of the time, bridge
drivers will pick a default bus format or extract this piece of
information from somewhere else, like a FW property).
v10:
* Add changelog to the commit message
v9:
* No changes
v8:
* Fix a test in drm_atomic_bridge_chain_select_bus_fmts() (Reported by
Jonas)
v7:
* Adapt the code to deal with the fact that not all bridges in the
chain have a bridge state
v5 -> v6:
* No changes
v4:
* Enhance the doc
* Fix typos
* Rename some parameters/fields
* Reword the commit message
v3:
* Fix the commit message (Reported by Laurent)
* Document the fact that bus formats should not be directly modified by
drivers (Suggested by Laurent)
* Document the fact that format order matters (Suggested by Laurent)
* Propagate bus flags by default
* Document the fact that drivers can tweak bus flags if needed
* Let ->atomic_get_{output,input}_bus_fmts() allocate the bus format
array (Suggested by Laurent)
* Add a drm_atomic_helper_bridge_propagate_bus_fmt()
* Mandate that bridge drivers return accurate input_fmts even if they
are known to be the first element in the bridge chain
v2:
* Rework things to support more complex use cases
Signed-off-by: Boris Brezillon <boris.brezillon@collabora.com>
Signed-off-by: Neil Armstrong <narmstrong@baylibre.com>
[narmstrong: fixed doc in include/drm/drm_bridge.h:69 fmt->format]
Reviewed-by: Jernej Skrabec <jernej.skrabec@siol.net>
Tested-by: Jonas Karlman <jonas@kwiboo.se>
Link: https://patchwork.freedesktop.org/patch/msgid/20200128135514.108171-7-boris.brezillon@collabora.com
2020-01-28 06:55:08 -07:00
|
|
|
* format negotiation).
|
|
|
|
*/
|
|
|
|
u32 format;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @flags: DRM_BUS_* flags used on this bus
|
|
|
|
*/
|
|
|
|
u32 flags;
|
|
|
|
};
|
|
|
|
|
2020-01-28 06:55:03 -07:00
|
|
|
/**
|
|
|
|
* struct drm_bridge_state - Atomic bridge state object
|
|
|
|
*/
|
|
|
|
struct drm_bridge_state {
|
|
|
|
/**
|
|
|
|
* @base: inherit from &drm_private_state
|
|
|
|
*/
|
|
|
|
struct drm_private_state base;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @bridge: the bridge this state refers to
|
|
|
|
*/
|
|
|
|
struct drm_bridge *bridge;
|
drm/bridge: Add the necessary bits to support bus format negotiation
drm_bridge_state is extended to describe the input and output bus
configurations. These bus configurations are exposed through the
drm_bus_cfg struct which encodes the configuration of a physical
bus between two components in an output pipeline, usually between
two bridges, an encoder and a bridge, or a bridge and a connector.
The bus configuration is stored in drm_bridge_state separately for
the input and output buses, as seen from the point of view of each
bridge. The bus configuration of a bridge output is usually identical
to the configuration of the next bridge's input, but may differ if
the signals are modified between the two bridges, for instance by an
inverter on the board. The input and output configurations of a
bridge may differ if the bridge modifies the signals internally,
for instance by performing format conversion, or*modifying signals
polarities.
Bus format negotiation is automated by the core, drivers just have
to implement the ->atomic_get_{output,input}_bus_fmts() hooks if they
want to take part to this negotiation. Negotiation happens in reverse
order, starting from the last element of the chain (the one directly
connected to the display) up to the first element of the chain (the one
connected to the encoder).
During this negotiation all supported formats are tested until we find
one that works, meaning that the formats array should be in decreasing
preference order (assuming the driver has a preference order).
Note that the bus format negotiation works even if some elements in the
chain don't implement the ->atomic_get_{output,input}_bus_fmts() hooks.
In that case, the core advertises only MEDIA_BUS_FMT_FIXED and lets
the previous bridge element decide what to do (most of the time, bridge
drivers will pick a default bus format or extract this piece of
information from somewhere else, like a FW property).
v10:
* Add changelog to the commit message
v9:
* No changes
v8:
* Fix a test in drm_atomic_bridge_chain_select_bus_fmts() (Reported by
Jonas)
v7:
* Adapt the code to deal with the fact that not all bridges in the
chain have a bridge state
v5 -> v6:
* No changes
v4:
* Enhance the doc
* Fix typos
* Rename some parameters/fields
* Reword the commit message
v3:
* Fix the commit message (Reported by Laurent)
* Document the fact that bus formats should not be directly modified by
drivers (Suggested by Laurent)
* Document the fact that format order matters (Suggested by Laurent)
* Propagate bus flags by default
* Document the fact that drivers can tweak bus flags if needed
* Let ->atomic_get_{output,input}_bus_fmts() allocate the bus format
array (Suggested by Laurent)
* Add a drm_atomic_helper_bridge_propagate_bus_fmt()
* Mandate that bridge drivers return accurate input_fmts even if they
are known to be the first element in the bridge chain
v2:
* Rework things to support more complex use cases
Signed-off-by: Boris Brezillon <boris.brezillon@collabora.com>
Signed-off-by: Neil Armstrong <narmstrong@baylibre.com>
[narmstrong: fixed doc in include/drm/drm_bridge.h:69 fmt->format]
Reviewed-by: Jernej Skrabec <jernej.skrabec@siol.net>
Tested-by: Jonas Karlman <jonas@kwiboo.se>
Link: https://patchwork.freedesktop.org/patch/msgid/20200128135514.108171-7-boris.brezillon@collabora.com
2020-01-28 06:55:08 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @input_bus_cfg: input bus configuration
|
|
|
|
*/
|
|
|
|
struct drm_bus_cfg input_bus_cfg;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @output_bus_cfg: input bus configuration
|
|
|
|
*/
|
|
|
|
struct drm_bus_cfg output_bus_cfg;
|
2020-01-28 06:55:03 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
static inline struct drm_bridge_state *
|
|
|
|
drm_priv_to_bridge_state(struct drm_private_state *priv)
|
|
|
|
{
|
|
|
|
return container_of(priv, struct drm_bridge_state, base);
|
|
|
|
}
|
|
|
|
|
|
|
|
struct drm_bridge_state *
|
|
|
|
drm_atomic_get_bridge_state(struct drm_atomic_state *state,
|
|
|
|
struct drm_bridge *bridge);
|
|
|
|
struct drm_bridge_state *
|
|
|
|
drm_atomic_get_old_bridge_state(struct drm_atomic_state *state,
|
|
|
|
struct drm_bridge *bridge);
|
|
|
|
struct drm_bridge_state *
|
|
|
|
drm_atomic_get_new_bridge_state(struct drm_atomic_state *state,
|
|
|
|
struct drm_bridge *bridge);
|
|
|
|
|
2014-07-25 13:30:38 -06:00
|
|
|
#endif /* DRM_ATOMIC_H_ */
|