2008-11-08 01:05:41 +03:00
|
|
|
/*
|
|
|
|
* Copyright © 2006 Keith Packard
|
|
|
|
* Copyright © 2007-2008 Dave Airlie
|
|
|
|
* Copyright © 2007-2008 Intel Corporation
|
|
|
|
* Jesse Barnes <jesse.barnes@intel.com>
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
#ifndef __DRM_CRTC_H__
|
|
|
|
#define __DRM_CRTC_H__
|
|
|
|
|
|
|
|
#include <linux/i2c.h>
|
|
|
|
#include <linux/spinlock.h>
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/fb.h>
|
2013-12-19 14:04:07 +04:00
|
|
|
#include <linux/hdmi.h>
|
2014-07-22 14:09:10 +04:00
|
|
|
#include <linux/media-bus-format.h>
|
2014-08-29 14:12:40 +04:00
|
|
|
#include <uapi/drm/drm_mode.h>
|
|
|
|
#include <uapi/drm/drm_fourcc.h>
|
2013-11-19 21:10:12 +04:00
|
|
|
#include <drm/drm_modeset_lock.h>
|
2016-07-26 19:06:57 +03:00
|
|
|
#include <drm/drm_rect.h>
|
2016-08-29 11:27:51 +03:00
|
|
|
#include <drm/drm_mode_object.h>
|
2016-08-15 17:07:02 +03:00
|
|
|
#include <drm/drm_framebuffer.h>
|
|
|
|
#include <drm/drm_modes.h>
|
2016-08-12 23:48:50 +03:00
|
|
|
#include <drm/drm_connector.h>
|
2019-06-08 11:02:35 +03:00
|
|
|
#include <drm/drm_device.h>
|
2016-08-29 11:27:55 +03:00
|
|
|
#include <drm/drm_property.h>
|
2016-08-31 19:09:06 +03:00
|
|
|
#include <drm/drm_edid.h>
|
2016-09-21 11:59:24 +03:00
|
|
|
#include <drm/drm_plane.h>
|
2016-09-21 11:59:26 +03:00
|
|
|
#include <drm/drm_blend.h>
|
2016-09-21 11:59:28 +03:00
|
|
|
#include <drm/drm_color_mgmt.h>
|
2016-10-06 18:21:06 +03:00
|
|
|
#include <drm/drm_debugfs_crc.h>
|
2016-11-14 14:58:23 +03:00
|
|
|
#include <drm/drm_mode_config.h>
|
2011-11-15 02:51:28 +04:00
|
|
|
|
2008-11-08 01:05:41 +03:00
|
|
|
struct drm_device;
|
|
|
|
struct drm_mode_set;
|
2012-11-21 18:00:47 +04:00
|
|
|
struct drm_file;
|
|
|
|
struct drm_clip_rect;
|
2016-11-05 18:08:09 +03:00
|
|
|
struct drm_printer;
|
2019-06-12 17:50:19 +03:00
|
|
|
struct drm_self_refresh_data;
|
2014-06-15 14:07:12 +04:00
|
|
|
struct device_node;
|
2016-10-25 15:00:45 +03:00
|
|
|
struct dma_fence;
|
2016-06-21 11:54:13 +03:00
|
|
|
struct edid;
|
2008-11-08 01:05:41 +03:00
|
|
|
|
2012-09-13 07:22:31 +04:00
|
|
|
static inline int64_t U642I64(uint64_t val)
|
|
|
|
{
|
|
|
|
return (int64_t)*((int64_t *)&val);
|
|
|
|
}
|
|
|
|
static inline uint64_t I642U64(int64_t val)
|
|
|
|
{
|
|
|
|
return (uint64_t)*((uint64_t *)&val);
|
|
|
|
}
|
|
|
|
|
2008-11-08 01:05:41 +03:00
|
|
|
struct drm_crtc;
|
2009-11-17 20:43:55 +03:00
|
|
|
struct drm_pending_vblank_event;
|
2011-11-15 02:51:27 +04:00
|
|
|
struct drm_plane;
|
2013-08-15 00:47:37 +04:00
|
|
|
struct drm_bridge;
|
2014-10-27 22:28:44 +03:00
|
|
|
struct drm_atomic_state;
|
|
|
|
|
2015-12-04 11:45:45 +03:00
|
|
|
struct drm_crtc_helper_funcs;
|
|
|
|
struct drm_plane_helper_funcs;
|
|
|
|
|
2014-10-27 22:28:44 +03:00
|
|
|
/**
|
2014-07-25 23:30:38 +04:00
|
|
|
* struct drm_crtc_state - mutable CRTC state
|
2014-11-26 18:57:41 +03:00
|
|
|
*
|
2019-03-15 01:04:18 +03:00
|
|
|
* Note that the distinction between @enable and @active is rather subtle:
|
2014-11-26 18:57:41 +03:00
|
|
|
* Flipping @active while @enable is set without changing anything else may
|
2017-01-25 09:26:45 +03:00
|
|
|
* never return in a failure from the &drm_mode_config_funcs.atomic_check
|
|
|
|
* callback. Userspace assumes that a DPMS On will always succeed. In other
|
|
|
|
* words: @enable controls resource assignment, @active controls the actual
|
|
|
|
* hardware state.
|
2016-10-13 12:47:08 +03:00
|
|
|
*
|
|
|
|
* The three booleans active_changed, connectors_changed and mode_changed are
|
|
|
|
* intended to indicate whether a full modeset is needed, rather than strictly
|
2018-07-09 11:40:15 +03:00
|
|
|
* describing what has changed in a commit. See also:
|
|
|
|
* drm_atomic_crtc_needs_modeset()
|
|
|
|
*
|
|
|
|
* WARNING: Transitional helpers (like drm_helper_crtc_mode_set() or
|
|
|
|
* drm_helper_crtc_mode_set_base()) do not maintain many of the derived control
|
|
|
|
* state like @plane_mask so drivers not converted over to atomic helpers should
|
|
|
|
* not rely on these being accurate!
|
2014-10-27 22:28:44 +03:00
|
|
|
*/
|
|
|
|
struct drm_crtc_state {
|
2018-07-09 11:40:15 +03:00
|
|
|
/** @crtc: backpointer to the CRTC */
|
2014-11-27 17:49:39 +03:00
|
|
|
struct drm_crtc *crtc;
|
|
|
|
|
2018-07-09 11:40:15 +03:00
|
|
|
/**
|
|
|
|
* @enable: Whether the CRTC should be enabled, gates all other state.
|
|
|
|
* This controls reservations of shared resources. Actual hardware state
|
|
|
|
* is controlled by @active.
|
|
|
|
*/
|
2014-07-25 23:30:38 +04:00
|
|
|
bool enable;
|
2018-07-09 11:40:15 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @active: Whether the CRTC is actively displaying (used for DPMS).
|
|
|
|
* Implies that @enable is set. The driver must not release any shared
|
|
|
|
* resources if @active is set to false but @enable still true, because
|
|
|
|
* userspace expects that a DPMS ON always succeeds.
|
|
|
|
*
|
|
|
|
* Hence drivers must not consult @active in their various
|
|
|
|
* &drm_mode_config_funcs.atomic_check callback to reject an atomic
|
|
|
|
* commit. They can consult it to aid in the computation of derived
|
|
|
|
* hardware state, since even in the DPMS OFF state the display hardware
|
|
|
|
* should be as much powered down as when the CRTC is completely
|
|
|
|
* disabled through setting @enable to false.
|
|
|
|
*/
|
2014-11-26 18:57:41 +03:00
|
|
|
bool active;
|
2014-10-27 22:28:44 +03:00
|
|
|
|
2018-07-09 11:40:15 +03:00
|
|
|
/**
|
|
|
|
* @planes_changed: Planes on this crtc are updated. Used by the atomic
|
|
|
|
* helpers and drivers to steer the atomic commit control flow.
|
|
|
|
*/
|
2014-11-05 02:14:14 +03:00
|
|
|
bool planes_changed : 1;
|
2018-07-09 11:40:15 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @mode_changed: @mode or @enable has been changed. Used by the atomic
|
|
|
|
* helpers and drivers to steer the atomic commit control flow. See also
|
|
|
|
* drm_atomic_crtc_needs_modeset().
|
|
|
|
*
|
|
|
|
* Drivers are supposed to set this for any CRTC state changes that
|
|
|
|
* require a full modeset. They can also reset it to false if e.g. a
|
|
|
|
* @mode change can be done without a full modeset by only changing
|
|
|
|
* scaler settings.
|
|
|
|
*/
|
drm: Atomic crtc/connector updates using crtc/plane helper interfaces
So this is finally the integration of the crtc and plane helper
interfaces into the atomic helper functions.
In the check function we now have a few steps:
- First we update the output routing and figure out which crtcs need a
full mode set. Suitable encoders are selected using ->best_encoder,
with the same semantics as the crtc helpers of implicitly disabling
all connectors currently using the encoder.
- Then we pull all other connectors into the state update which feed
from a crtc which changes. This must be done do catch mode changes
and similar updates - atomic updates are differences on top of the
current state.
- Then we call all the various ->mode_fixup to compute the adjusted
mode. Note that here we have a slight semantic difference compared
to the crtc helpers: We have not yet updated the encoder->crtc link
when calling the encoder's ->mode_fixup function. But that's a
requirement when converting to atomic since we want to prepare the
entire state completely contained with the over drm_atomic_state
structure. So this must be carefully checked when converting drivers
over to atomic helpers.
- Finally we do call the atomic_check functions on planes and crtcs.
The commit function is also quite a beast:
- The only step that can fail is done first, namely pinning the
framebuffers. After that we cross the point of no return, an async
commit would push all that into the worker thread.
- The disabling of encoders and connectors is a bit tricky, since
depending upon the final state we need to select different crtc
helper functions.
- Software tracking is a bit clarified compared to the crtc helpers:
We commit the software state before starting to touch the hardware,
like crtc helpers. But since we just swap them we still have the old
state (i.e. the current hw state) around, which is really handy to
write simple disable functions. So no more
drm_crtc_helper_disable_all_unused_functions kind of fun because
we're leaving unused crtcs/encoders behind. Everything gets shut
down in-order now, which is one of the key differences of the i915
helpers compared to crtc helpers and a really nice additional
guarantee.
- Like with the plane helpers the atomic commit function waits for one
vblank to pass before calling the framebuffer cleanup function.
Compared to Rob's helper approach there's a bunch of upsides:
- All the interfaces which can fail are called in the ->check hook
(i.e. ->best_match and the various ->mode_fixup hooks). This means
that drivers can just reuse those functions and don't need to move
everything into ->atomic_check callbacks. If drivers have no need
for additional constraint checking beyong their existing crtc
helper callbacks they don't need to do anything.
- The actual commit operation is properly stage: First we prepare
framebuffers, which can potentially still fail (due to memory
exhausting). This is important for the async case, where this must
be done synchronously to correctly return errors.
- The output configuration changes (done with crtc helper functions)
and the plane update (using atomic plane helpers) are correctly
interleaved: First we shut down any crtcs that need changing, then
we update planes and finally we enable everything again. Hardware
without GO bits must be more careful with ordering, which this
sequence enables.
- Also for hardware with shared output resources (like display PLLs)
we first must shut down the old configuration before we can enable
the new one. Otherwise we can hit an impossible intermediate state
where there's not enough PLLs (which is the point behind atomic
updates).
v2:
- Ensure that users of ->check update crtc_state->enable correctly.
- Update the legacy state in crtc/plane structures. Eventually we want
to remove that, but for now the drm core still expects this (especially
the plane->fb pointer).
v3: A few changes for better async handling:
- Reorder the software side state commit so that it happens all before
we touch the hardware. This way async support becomes very easy
since we can punt all the actual hw touching to a worker thread. And
as long as we synchronize with that thread (flushing or cancelling,
depending upon what the driver can handle) before we commit the next
software state there's no need for any locking in the worker thread
at all. Which greatly simplifies things.
And as long as we synchronize with all relevant threads we can have
a lot of them (e.g. per-crtc for per-crtc updates) running in
parallel.
- Expose pre/post plane commit steps separately. We need to expose the
actual hw commit step anyway for drivers to be able to implement
asynchronous commit workers. But if we expose pre/post and plane
commit steps individually we allow drivers to selectively use atomic
helpers.
- I've forgotten to call encoder/bridge ->mode_set functions, fix
this.
v4: Add debug output and fix a mixup between current and new state
that resulted in crtcs not getting updated correctly. And in an
Oops ...
v5:
- Be kind to driver writers in the vblank wait functions.. if thing
aren't working yet, and vblank irq will never come, then let's not
block forever.. especially under console-lock.
- Correctly clear connector_state->best_encoder when disabling.
Spotted while trying to understand a report from Rob Clark.
- Only steal encoder if it actually changed, otherwise hilarity ensues
if we steal from the current connector and so set the ->crtc pointer
unexpectedly to NULL. Reported by Rob Clark.
- Bail out in disable_outputs if an output currently doesn't have a
best_encoder - this means it's already disabled.
v6: Fixupe kerneldoc as reported by Paulo. And also fix up kerneldoc
in drm_crtc.h.
v7: Take ownership of the atomic state and clean it up with
drm_atomic_state_free().
v8 Various improvements all over:
- Polish code comments and kerneldoc.
- Improve debug output to make sure all failure cases are logged.
- Treat enabled crtc with no connectors as invalid input from userspace.
- Don't ignore the return value from mode_fixup().
v9:
- Improve debug output for crtc_state->mode_changed.
v10:
- Fixup the vblank waiting code to properly balance the vblank_get/put
calls.
- Better comments when checking/computing crtc->mode_changed
v11: Fixup the encoder stealing logic: We can't look at encoder->crtc
since that's not in the atomic state structures and might be updated
asynchronously in and async commit. Instead we need to inspect all the
connector states and check whether the encoder is currently in used
and if so, on which crtc.
v12: Review from Sean:
- A few spelling fixes.
- Flatten control flow indent by converting if blocks to early
continue/return in 2 places.
- Capture connectors_for_crtc return value in int num_connectors
instead of bool has_connectors and do an explicit int->bool
conversion with !!. I think the helper is more useful for drivers if
it returns the number of connectors (e.g. to detect cloning
configurations), so decided to keep that return value.
Cc: Sean Paul <seanpaul@chromium.org>
Cc: Paulo Zanoni <przanoni@gmail.com>
Cc: Rob Clark <robdclark@gmail.com>
Reviewed-by: Sean Paul <seanpaul@chromium.org>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2014-09-16 19:50:47 +04:00
|
|
|
bool mode_changed : 1;
|
2018-07-09 11:40:15 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @active_changed: @active has been toggled. Used by the atomic
|
|
|
|
* helpers and drivers to steer the atomic commit control flow. See also
|
|
|
|
* drm_atomic_crtc_needs_modeset().
|
|
|
|
*/
|
2015-01-22 18:36:21 +03:00
|
|
|
bool active_changed : 1;
|
2018-07-09 11:40:15 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @connectors_changed: Connectors to this crtc have been updated,
|
|
|
|
* either in their state or routing. Used by the atomic
|
|
|
|
* helpers and drivers to steer the atomic commit control flow. See also
|
|
|
|
* drm_atomic_crtc_needs_modeset().
|
|
|
|
*
|
|
|
|
* Drivers are supposed to set this as-needed from their own atomic
|
|
|
|
* check code, e.g. from &drm_encoder_helper_funcs.atomic_check
|
|
|
|
*/
|
2015-07-21 14:28:57 +03:00
|
|
|
bool connectors_changed : 1;
|
2018-07-09 11:40:15 +03:00
|
|
|
/**
|
|
|
|
* @zpos_changed: zpos values of planes on this crtc have been updated.
|
|
|
|
* Used by the atomic helpers and drivers to steer the atomic commit
|
|
|
|
* control flow.
|
|
|
|
*/
|
2016-06-13 12:11:26 +03:00
|
|
|
bool zpos_changed : 1;
|
2018-07-09 11:40:15 +03:00
|
|
|
/**
|
|
|
|
* @color_mgmt_changed: Color management properties have changed
|
|
|
|
* (@gamma_lut, @degamma_lut or @ctm). Used by the atomic helpers and
|
|
|
|
* drivers to steer the atomic commit control flow.
|
|
|
|
*/
|
2016-02-26 20:05:00 +03:00
|
|
|
bool color_mgmt_changed : 1;
|
drm: Atomic crtc/connector updates using crtc/plane helper interfaces
So this is finally the integration of the crtc and plane helper
interfaces into the atomic helper functions.
In the check function we now have a few steps:
- First we update the output routing and figure out which crtcs need a
full mode set. Suitable encoders are selected using ->best_encoder,
with the same semantics as the crtc helpers of implicitly disabling
all connectors currently using the encoder.
- Then we pull all other connectors into the state update which feed
from a crtc which changes. This must be done do catch mode changes
and similar updates - atomic updates are differences on top of the
current state.
- Then we call all the various ->mode_fixup to compute the adjusted
mode. Note that here we have a slight semantic difference compared
to the crtc helpers: We have not yet updated the encoder->crtc link
when calling the encoder's ->mode_fixup function. But that's a
requirement when converting to atomic since we want to prepare the
entire state completely contained with the over drm_atomic_state
structure. So this must be carefully checked when converting drivers
over to atomic helpers.
- Finally we do call the atomic_check functions on planes and crtcs.
The commit function is also quite a beast:
- The only step that can fail is done first, namely pinning the
framebuffers. After that we cross the point of no return, an async
commit would push all that into the worker thread.
- The disabling of encoders and connectors is a bit tricky, since
depending upon the final state we need to select different crtc
helper functions.
- Software tracking is a bit clarified compared to the crtc helpers:
We commit the software state before starting to touch the hardware,
like crtc helpers. But since we just swap them we still have the old
state (i.e. the current hw state) around, which is really handy to
write simple disable functions. So no more
drm_crtc_helper_disable_all_unused_functions kind of fun because
we're leaving unused crtcs/encoders behind. Everything gets shut
down in-order now, which is one of the key differences of the i915
helpers compared to crtc helpers and a really nice additional
guarantee.
- Like with the plane helpers the atomic commit function waits for one
vblank to pass before calling the framebuffer cleanup function.
Compared to Rob's helper approach there's a bunch of upsides:
- All the interfaces which can fail are called in the ->check hook
(i.e. ->best_match and the various ->mode_fixup hooks). This means
that drivers can just reuse those functions and don't need to move
everything into ->atomic_check callbacks. If drivers have no need
for additional constraint checking beyong their existing crtc
helper callbacks they don't need to do anything.
- The actual commit operation is properly stage: First we prepare
framebuffers, which can potentially still fail (due to memory
exhausting). This is important for the async case, where this must
be done synchronously to correctly return errors.
- The output configuration changes (done with crtc helper functions)
and the plane update (using atomic plane helpers) are correctly
interleaved: First we shut down any crtcs that need changing, then
we update planes and finally we enable everything again. Hardware
without GO bits must be more careful with ordering, which this
sequence enables.
- Also for hardware with shared output resources (like display PLLs)
we first must shut down the old configuration before we can enable
the new one. Otherwise we can hit an impossible intermediate state
where there's not enough PLLs (which is the point behind atomic
updates).
v2:
- Ensure that users of ->check update crtc_state->enable correctly.
- Update the legacy state in crtc/plane structures. Eventually we want
to remove that, but for now the drm core still expects this (especially
the plane->fb pointer).
v3: A few changes for better async handling:
- Reorder the software side state commit so that it happens all before
we touch the hardware. This way async support becomes very easy
since we can punt all the actual hw touching to a worker thread. And
as long as we synchronize with that thread (flushing or cancelling,
depending upon what the driver can handle) before we commit the next
software state there's no need for any locking in the worker thread
at all. Which greatly simplifies things.
And as long as we synchronize with all relevant threads we can have
a lot of them (e.g. per-crtc for per-crtc updates) running in
parallel.
- Expose pre/post plane commit steps separately. We need to expose the
actual hw commit step anyway for drivers to be able to implement
asynchronous commit workers. But if we expose pre/post and plane
commit steps individually we allow drivers to selectively use atomic
helpers.
- I've forgotten to call encoder/bridge ->mode_set functions, fix
this.
v4: Add debug output and fix a mixup between current and new state
that resulted in crtcs not getting updated correctly. And in an
Oops ...
v5:
- Be kind to driver writers in the vblank wait functions.. if thing
aren't working yet, and vblank irq will never come, then let's not
block forever.. especially under console-lock.
- Correctly clear connector_state->best_encoder when disabling.
Spotted while trying to understand a report from Rob Clark.
- Only steal encoder if it actually changed, otherwise hilarity ensues
if we steal from the current connector and so set the ->crtc pointer
unexpectedly to NULL. Reported by Rob Clark.
- Bail out in disable_outputs if an output currently doesn't have a
best_encoder - this means it's already disabled.
v6: Fixupe kerneldoc as reported by Paulo. And also fix up kerneldoc
in drm_crtc.h.
v7: Take ownership of the atomic state and clean it up with
drm_atomic_state_free().
v8 Various improvements all over:
- Polish code comments and kerneldoc.
- Improve debug output to make sure all failure cases are logged.
- Treat enabled crtc with no connectors as invalid input from userspace.
- Don't ignore the return value from mode_fixup().
v9:
- Improve debug output for crtc_state->mode_changed.
v10:
- Fixup the vblank waiting code to properly balance the vblank_get/put
calls.
- Better comments when checking/computing crtc->mode_changed
v11: Fixup the encoder stealing logic: We can't look at encoder->crtc
since that's not in the atomic state structures and might be updated
asynchronously in and async commit. Instead we need to inspect all the
connector states and check whether the encoder is currently in used
and if so, on which crtc.
v12: Review from Sean:
- A few spelling fixes.
- Flatten control flow indent by converting if blocks to early
continue/return in 2 places.
- Capture connectors_for_crtc return value in int num_connectors
instead of bool has_connectors and do an explicit int->bool
conversion with !!. I think the helper is more useful for drivers if
it returns the number of connectors (e.g. to detect cloning
configurations), so decided to keep that return value.
Cc: Sean Paul <seanpaul@chromium.org>
Cc: Paulo Zanoni <przanoni@gmail.com>
Cc: Rob Clark <robdclark@gmail.com>
Reviewed-by: Sean Paul <seanpaul@chromium.org>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2014-09-16 19:50:47 +04:00
|
|
|
|
2018-07-03 10:50:19 +03:00
|
|
|
/**
|
|
|
|
* @no_vblank:
|
|
|
|
*
|
|
|
|
* Reflects the ability of a CRTC to send VBLANK events. This state
|
2020-01-29 15:05:17 +03:00
|
|
|
* usually depends on the pipeline configuration. If set to true, DRM
|
|
|
|
* atomic helpers will send out a fake VBLANK event during display
|
|
|
|
* updates after all hardware changes have been committed. This is
|
|
|
|
* implemented in drm_atomic_helper_fake_vblank().
|
|
|
|
*
|
|
|
|
* One usage is for drivers and/or hardware without support for VBLANK
|
|
|
|
* interrupts. Such drivers typically do not initialize vblanking
|
|
|
|
* (i.e., call drm_vblank_init() with the number of CRTCs). For CRTCs
|
|
|
|
* without initialized vblanking, this field is set to true in
|
|
|
|
* drm_atomic_helper_check_modeset(), and a fake VBLANK event will be
|
|
|
|
* send out on each update of the display pipeline by
|
|
|
|
* drm_atomic_helper_fake_vblank().
|
|
|
|
*
|
|
|
|
* Another usage is CRTCs feeding a writeback connector operating in
|
|
|
|
* oneshot mode. In this case the fake VBLANK event is only generated
|
|
|
|
* when a job is queued to the writeback connector, and we want the
|
|
|
|
* core to fake VBLANK events when this part of the pipeline hasn't
|
|
|
|
* changed but others had or when the CRTC and connectors are being
|
|
|
|
* disabled.
|
2018-07-03 10:50:19 +03:00
|
|
|
*
|
|
|
|
* __drm_atomic_helper_crtc_duplicate_state() will not reset the value
|
|
|
|
* from the current state, the CRTC driver is then responsible for
|
|
|
|
* updating this field when needed.
|
|
|
|
*
|
|
|
|
* Note that the combination of &drm_crtc_state.event == NULL and
|
|
|
|
* &drm_crtc_state.no_blank == true is valid and usually used when the
|
|
|
|
* writeback connector attached to the CRTC has a new job queued. In
|
|
|
|
* this case the driver will send the VBLANK event on its own when the
|
|
|
|
* writeback job is complete.
|
|
|
|
*/
|
|
|
|
bool no_vblank : 1;
|
|
|
|
|
2018-07-09 11:40:15 +03:00
|
|
|
/**
|
|
|
|
* @plane_mask: Bitmask of drm_plane_mask(plane) of planes attached to
|
|
|
|
* this CRTC.
|
2014-11-21 23:28:31 +03:00
|
|
|
*/
|
|
|
|
u32 plane_mask;
|
|
|
|
|
2018-07-09 11:40:15 +03:00
|
|
|
/**
|
|
|
|
* @connector_mask: Bitmask of drm_connector_mask(connector) of
|
|
|
|
* connectors attached to this CRTC.
|
|
|
|
*/
|
2016-01-04 14:53:18 +03:00
|
|
|
u32 connector_mask;
|
2018-07-09 11:40:15 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @encoder_mask: Bitmask of drm_encoder_mask(encoder) of encoders
|
|
|
|
* attached to this CRTC.
|
|
|
|
*/
|
2016-01-28 17:04:58 +03:00
|
|
|
u32 encoder_mask;
|
2016-01-04 14:53:18 +03:00
|
|
|
|
2017-05-15 12:11:35 +03:00
|
|
|
/**
|
|
|
|
* @adjusted_mode:
|
|
|
|
*
|
|
|
|
* Internal display timings which can be used by the driver to handle
|
|
|
|
* differences between the mode requested by userspace in @mode and what
|
2018-04-09 18:24:27 +03:00
|
|
|
* is actually programmed into the hardware.
|
|
|
|
*
|
2018-07-09 11:40:15 +03:00
|
|
|
* For drivers using &drm_bridge, this stores hardware display timings
|
2018-04-09 18:24:27 +03:00
|
|
|
* used between the CRTC and the first bridge. For other drivers, the
|
|
|
|
* meaning of the adjusted_mode field is purely driver implementation
|
|
|
|
* defined information, and will usually be used to store the hardware
|
|
|
|
* display timings used between the CRTC and encoder blocks.
|
2017-05-15 12:11:35 +03:00
|
|
|
*/
|
2014-10-29 13:13:47 +03:00
|
|
|
struct drm_display_mode adjusted_mode;
|
|
|
|
|
2017-05-15 12:11:35 +03:00
|
|
|
/**
|
|
|
|
* @mode:
|
|
|
|
*
|
|
|
|
* Display timings requested by userspace. The driver should try to
|
|
|
|
* match the refresh rate as close as possible (but note that it's
|
|
|
|
* undefined what exactly is close enough, e.g. some of the HDMI modes
|
|
|
|
* only differ in less than 1% of the refresh rate). The active width
|
|
|
|
* and height as observed by userspace for positioning planes must match
|
|
|
|
* exactly.
|
|
|
|
*
|
|
|
|
* For external connectors where the sink isn't fixed (like with a
|
|
|
|
* built-in panel), this mode here should match the physical mode on the
|
|
|
|
* wire to the last details (i.e. including sync polarities and
|
|
|
|
* everything).
|
|
|
|
*/
|
2014-10-27 22:28:44 +03:00
|
|
|
struct drm_display_mode mode;
|
|
|
|
|
2018-07-09 11:40:15 +03:00
|
|
|
/**
|
|
|
|
* @mode_blob: &drm_property_blob for @mode, for exposing the mode to
|
|
|
|
* atomic userspace.
|
|
|
|
*/
|
2015-05-25 21:11:51 +03:00
|
|
|
struct drm_property_blob *mode_blob;
|
|
|
|
|
2017-04-12 18:20:06 +03:00
|
|
|
/**
|
|
|
|
* @degamma_lut:
|
|
|
|
*
|
|
|
|
* Lookup table for converting framebuffer pixel data before apply the
|
|
|
|
* color conversion matrix @ctm. See drm_crtc_enable_color_mgmt(). The
|
|
|
|
* blob (if not NULL) is an array of &struct drm_color_lut.
|
|
|
|
*/
|
2016-02-26 20:05:00 +03:00
|
|
|
struct drm_property_blob *degamma_lut;
|
2017-04-12 18:20:06 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @ctm:
|
|
|
|
*
|
|
|
|
* Color transformation matrix. See drm_crtc_enable_color_mgmt(). The
|
|
|
|
* blob (if not NULL) is a &struct drm_color_ctm.
|
|
|
|
*/
|
2016-02-26 20:05:00 +03:00
|
|
|
struct drm_property_blob *ctm;
|
2017-04-12 18:20:06 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @gamma_lut:
|
|
|
|
*
|
|
|
|
* Lookup table for converting pixel data after the color conversion
|
|
|
|
* matrix @ctm. See drm_crtc_enable_color_mgmt(). The blob (if not
|
|
|
|
* NULL) is an array of &struct drm_color_lut.
|
|
|
|
*/
|
2016-02-26 20:05:00 +03:00
|
|
|
struct drm_property_blob *gamma_lut;
|
|
|
|
|
2017-01-06 23:39:40 +03:00
|
|
|
/**
|
|
|
|
* @target_vblank:
|
|
|
|
*
|
|
|
|
* Target vertical blank period when a page flip
|
|
|
|
* should take effect.
|
|
|
|
*/
|
|
|
|
u32 target_vblank;
|
|
|
|
|
2017-02-03 00:56:29 +03:00
|
|
|
/**
|
2019-09-03 22:06:42 +03:00
|
|
|
* @async_flip:
|
2017-02-03 00:56:29 +03:00
|
|
|
*
|
2019-09-03 22:06:42 +03:00
|
|
|
* This is set when DRM_MODE_PAGE_FLIP_ASYNC is set in the legacy
|
|
|
|
* PAGE_FLIP IOCTL. It's not wired up for the atomic IOCTL itself yet.
|
2017-02-03 00:56:29 +03:00
|
|
|
*/
|
2019-09-03 22:06:42 +03:00
|
|
|
bool async_flip;
|
2017-02-03 00:56:29 +03:00
|
|
|
|
2018-10-04 18:46:07 +03:00
|
|
|
/**
|
|
|
|
* @vrr_enabled:
|
|
|
|
*
|
|
|
|
* Indicates if variable refresh rate should be enabled for the CRTC.
|
|
|
|
* Support for the requested vrr state will depend on driver and
|
|
|
|
* hardware capabiltiy - lacking support is not treated as failure.
|
|
|
|
*/
|
|
|
|
bool vrr_enabled;
|
|
|
|
|
2019-06-12 17:50:19 +03:00
|
|
|
/**
|
|
|
|
* @self_refresh_active:
|
|
|
|
*
|
|
|
|
* Used by the self refresh helpers to denote when a self refresh
|
|
|
|
* transition is occurring. This will be set on enable/disable callbacks
|
|
|
|
* when self refresh is being enabled or disabled. In some cases, it may
|
|
|
|
* not be desirable to fully shut off the crtc during self refresh.
|
|
|
|
* CRTC's can inspect this flag and determine the best course of action.
|
|
|
|
*/
|
|
|
|
bool self_refresh_active;
|
|
|
|
|
2016-09-30 13:04:56 +03:00
|
|
|
/**
|
|
|
|
* @event:
|
|
|
|
*
|
|
|
|
* Optional pointer to a DRM event to signal upon completion of the
|
|
|
|
* state update. The driver must send out the event when the atomic
|
|
|
|
* commit operation completes. There are two cases:
|
|
|
|
*
|
|
|
|
* - The event is for a CRTC which is being disabled through this
|
|
|
|
* atomic commit. In that case the event can be send out any time
|
|
|
|
* after the hardware has stopped scanning out the current
|
|
|
|
* framebuffers. It should contain the timestamp and counter for the
|
2017-05-24 17:51:48 +03:00
|
|
|
* last vblank before the display pipeline was shut off. The simplest
|
|
|
|
* way to achieve that is calling drm_crtc_send_vblank_event()
|
|
|
|
* somewhen after drm_crtc_vblank_off() has been called.
|
2016-09-30 13:04:56 +03:00
|
|
|
*
|
|
|
|
* - For a CRTC which is enabled at the end of the commit (even when it
|
|
|
|
* undergoes an full modeset) the vblank timestamp and counter must
|
|
|
|
* be for the vblank right before the first frame that scans out the
|
|
|
|
* new set of buffers. Again the event can only be sent out after the
|
|
|
|
* hardware has stopped scanning out the old buffers.
|
|
|
|
*
|
|
|
|
* - Events for disabled CRTCs are not allowed, and drivers can ignore
|
|
|
|
* that case.
|
|
|
|
*
|
2020-01-29 15:05:17 +03:00
|
|
|
* For very simple hardware without VBLANK interrupt, enabling
|
|
|
|
* &struct drm_crtc_state.no_vblank makes DRM's atomic commit helpers
|
|
|
|
* send a fake VBLANK event at the end of the display update after all
|
|
|
|
* hardware changes have been applied. See
|
|
|
|
* drm_atomic_helper_fake_vblank().
|
|
|
|
*
|
|
|
|
* For more complex hardware this
|
|
|
|
* can be handled by the drm_crtc_send_vblank_event() function,
|
2016-09-30 13:04:56 +03:00
|
|
|
* which the driver should call on the provided event upon completion of
|
|
|
|
* the atomic commit. Note that if the driver supports vblank signalling
|
|
|
|
* and timestamping the vblank counters and timestamps must agree with
|
|
|
|
* the ones returned from page flip events. With the current vblank
|
|
|
|
* helper infrastructure this can be achieved by holding a vblank
|
|
|
|
* reference while the page flip is pending, acquired through
|
|
|
|
* drm_crtc_vblank_get() and released with drm_crtc_vblank_put().
|
|
|
|
* Drivers are free to implement their own vblank counter and timestamp
|
|
|
|
* tracking though, e.g. if they have accurate timestamp registers in
|
|
|
|
* hardware.
|
|
|
|
*
|
|
|
|
* For hardware which supports some means to synchronize vblank
|
|
|
|
* interrupt delivery with committing display state there's also
|
|
|
|
* drm_crtc_arm_vblank_event(). See the documentation of that function
|
|
|
|
* for a detailed discussion of the constraints it needs to be used
|
|
|
|
* safely.
|
2017-03-08 17:12:39 +03:00
|
|
|
*
|
|
|
|
* If the device can't notify of flip completion in a race-free way
|
|
|
|
* at all, then the event should be armed just after the page flip is
|
|
|
|
* committed. In the worst case the driver will send the event to
|
|
|
|
* userspace one frame too late. This doesn't allow for a real atomic
|
|
|
|
* update, but it should avoid tearing.
|
2016-09-30 13:04:56 +03:00
|
|
|
*/
|
2014-10-27 22:28:44 +03:00
|
|
|
struct drm_pending_vblank_event *event;
|
|
|
|
|
2017-09-04 18:04:56 +03:00
|
|
|
/**
|
|
|
|
* @commit:
|
|
|
|
*
|
|
|
|
* This tracks how the commit for this update proceeds through the
|
|
|
|
* various phases. This is never cleared, except when we destroy the
|
|
|
|
* state, so that subsequent commits can synchronize with previous ones.
|
|
|
|
*/
|
|
|
|
struct drm_crtc_commit *commit;
|
|
|
|
|
2018-07-09 11:40:15 +03:00
|
|
|
/** @state: backpointer to global drm_atomic_state */
|
2014-10-27 22:28:44 +03:00
|
|
|
struct drm_atomic_state *state;
|
|
|
|
};
|
2008-11-08 01:05:41 +03:00
|
|
|
|
|
|
|
/**
|
2014-10-27 18:54:27 +03:00
|
|
|
* struct drm_crtc_funcs - control CRTCs for a given device
|
2008-11-08 01:05:41 +03:00
|
|
|
*
|
|
|
|
* The drm_crtc_funcs structure is the central CRTC management structure
|
|
|
|
* in the DRM. Each CRTC controls one or more connectors (note that the name
|
|
|
|
* CRTC is simply historical, a CRTC may control LVDS, VGA, DVI, TV out, etc.
|
|
|
|
* connectors, not just CRTs).
|
|
|
|
*
|
|
|
|
* Each driver is responsible for filling out this structure at startup time,
|
|
|
|
* in addition to providing other modesetting features, like i2c and DDC
|
|
|
|
* bus accessors.
|
|
|
|
*/
|
|
|
|
struct drm_crtc_funcs {
|
2015-12-04 11:45:48 +03:00
|
|
|
/**
|
|
|
|
* @reset:
|
|
|
|
*
|
|
|
|
* Reset CRTC hardware and software state to off. This function isn't
|
|
|
|
* called by the core directly, only through drm_mode_config_reset().
|
|
|
|
* It's not a helper hook only for historical reasons.
|
|
|
|
*
|
|
|
|
* Atomic drivers can use drm_atomic_helper_crtc_reset() to reset
|
|
|
|
* atomic state using this hook.
|
|
|
|
*/
|
2011-01-24 18:11:08 +03:00
|
|
|
void (*reset)(struct drm_crtc *crtc);
|
2008-11-08 01:05:41 +03:00
|
|
|
|
2015-12-04 11:46:00 +03:00
|
|
|
/**
|
|
|
|
* @cursor_set:
|
|
|
|
*
|
|
|
|
* Update the cursor image. The cursor position is relative to the CRTC
|
|
|
|
* and can be partially or fully outside of the visible area.
|
|
|
|
*
|
|
|
|
* Note that contrary to all other KMS functions the legacy cursor entry
|
|
|
|
* points don't take a framebuffer object, but instead take directly a
|
|
|
|
* raw buffer object id from the driver's buffer manager (which is
|
|
|
|
* either GEM or TTM for current drivers).
|
|
|
|
*
|
|
|
|
* This entry point is deprecated, drivers should instead implement
|
|
|
|
* universal plane support and register a proper cursor plane using
|
|
|
|
* drm_crtc_init_with_planes().
|
|
|
|
*
|
|
|
|
* This callback is optional
|
|
|
|
*
|
|
|
|
* RETURNS:
|
|
|
|
*
|
|
|
|
* 0 on success or a negative error code on failure.
|
|
|
|
*/
|
2008-11-08 01:05:41 +03:00
|
|
|
int (*cursor_set)(struct drm_crtc *crtc, struct drm_file *file_priv,
|
|
|
|
uint32_t handle, uint32_t width, uint32_t height);
|
2015-12-04 11:46:00 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @cursor_set2:
|
|
|
|
*
|
|
|
|
* Update the cursor image, including hotspot information. The hotspot
|
|
|
|
* must not affect the cursor position in CRTC coordinates, but is only
|
|
|
|
* meant as a hint for virtualized display hardware to coordinate the
|
|
|
|
* guests and hosts cursor position. The cursor hotspot is relative to
|
|
|
|
* the cursor image. Otherwise this works exactly like @cursor_set.
|
|
|
|
*
|
|
|
|
* This entry point is deprecated, drivers should instead implement
|
|
|
|
* universal plane support and register a proper cursor plane using
|
|
|
|
* drm_crtc_init_with_planes().
|
|
|
|
*
|
|
|
|
* This callback is optional.
|
|
|
|
*
|
|
|
|
* RETURNS:
|
|
|
|
*
|
|
|
|
* 0 on success or a negative error code on failure.
|
|
|
|
*/
|
2013-06-20 05:48:52 +04:00
|
|
|
int (*cursor_set2)(struct drm_crtc *crtc, struct drm_file *file_priv,
|
|
|
|
uint32_t handle, uint32_t width, uint32_t height,
|
|
|
|
int32_t hot_x, int32_t hot_y);
|
2015-12-04 11:46:00 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @cursor_move:
|
|
|
|
*
|
|
|
|
* Update the cursor position. The cursor does not need to be visible
|
|
|
|
* when this hook is called.
|
|
|
|
*
|
|
|
|
* This entry point is deprecated, drivers should instead implement
|
|
|
|
* universal plane support and register a proper cursor plane using
|
|
|
|
* drm_crtc_init_with_planes().
|
|
|
|
*
|
|
|
|
* This callback is optional.
|
|
|
|
*
|
|
|
|
* RETURNS:
|
|
|
|
*
|
|
|
|
* 0 on success or a negative error code on failure.
|
|
|
|
*/
|
2008-11-08 01:05:41 +03:00
|
|
|
int (*cursor_move)(struct drm_crtc *crtc, int x, int y);
|
|
|
|
|
2015-12-04 11:46:00 +03:00
|
|
|
/**
|
|
|
|
* @gamma_set:
|
|
|
|
*
|
|
|
|
* Set gamma on the CRTC.
|
|
|
|
*
|
|
|
|
* This callback is optional.
|
|
|
|
*
|
2017-04-12 18:20:06 +03:00
|
|
|
* Atomic drivers who want to support gamma tables should implement the
|
|
|
|
* atomic color management support, enabled by calling
|
|
|
|
* drm_crtc_enable_color_mgmt(), which then supports the legacy gamma
|
|
|
|
* interface through the drm_atomic_helper_legacy_gamma_set()
|
|
|
|
* compatibility implementation.
|
2015-12-04 11:46:00 +03:00
|
|
|
*/
|
2016-06-07 13:49:30 +03:00
|
|
|
int (*gamma_set)(struct drm_crtc *crtc, u16 *r, u16 *g, u16 *b,
|
2017-04-03 11:33:01 +03:00
|
|
|
uint32_t size,
|
|
|
|
struct drm_modeset_acquire_ctx *ctx);
|
2015-12-04 11:45:48 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @destroy:
|
|
|
|
*
|
2019-02-28 15:25:43 +03:00
|
|
|
* Clean up CRTC resources. This is only called at driver unload time
|
2015-12-04 11:45:48 +03:00
|
|
|
* through drm_mode_config_cleanup() since a CRTC cannot be hotplugged
|
|
|
|
* in DRM.
|
|
|
|
*/
|
2008-11-08 01:05:41 +03:00
|
|
|
void (*destroy)(struct drm_crtc *crtc);
|
|
|
|
|
2015-12-04 11:46:00 +03:00
|
|
|
/**
|
|
|
|
* @set_config:
|
|
|
|
*
|
|
|
|
* This is the main legacy entry point to change the modeset state on a
|
|
|
|
* CRTC. All the details of the desired configuration are passed in a
|
2016-12-29 23:48:26 +03:00
|
|
|
* &struct drm_mode_set - see there for details.
|
2015-12-04 11:46:00 +03:00
|
|
|
*
|
|
|
|
* Drivers implementing atomic modeset should use
|
|
|
|
* drm_atomic_helper_set_config() to implement this hook.
|
|
|
|
*
|
|
|
|
* RETURNS:
|
|
|
|
*
|
|
|
|
* 0 on success or a negative error code on failure.
|
|
|
|
*/
|
2017-03-23 00:50:57 +03:00
|
|
|
int (*set_config)(struct drm_mode_set *set,
|
|
|
|
struct drm_modeset_acquire_ctx *ctx);
|
2009-11-17 20:43:55 +03:00
|
|
|
|
2015-12-04 11:46:00 +03:00
|
|
|
/**
|
|
|
|
* @page_flip:
|
|
|
|
*
|
|
|
|
* Legacy entry point to schedule a flip to the given framebuffer.
|
|
|
|
*
|
|
|
|
* Page flipping is a synchronization mechanism that replaces the frame
|
|
|
|
* buffer being scanned out by the CRTC with a new frame buffer during
|
|
|
|
* vertical blanking, avoiding tearing (except when requested otherwise
|
|
|
|
* through the DRM_MODE_PAGE_FLIP_ASYNC flag). When an application
|
|
|
|
* requests a page flip the DRM core verifies that the new frame buffer
|
|
|
|
* is large enough to be scanned out by the CRTC in the currently
|
2017-01-25 09:26:45 +03:00
|
|
|
* configured mode and then calls this hook with a pointer to the new
|
|
|
|
* frame buffer.
|
2015-12-04 11:46:00 +03:00
|
|
|
*
|
|
|
|
* The driver must wait for any pending rendering to the new framebuffer
|
|
|
|
* to complete before executing the flip. It should also wait for any
|
|
|
|
* pending rendering from other drivers if the underlying buffer is a
|
|
|
|
* shared dma-buf.
|
|
|
|
*
|
|
|
|
* An application can request to be notified when the page flip has
|
2016-12-29 23:48:26 +03:00
|
|
|
* completed. The drm core will supply a &struct drm_event in the event
|
2015-12-04 11:46:00 +03:00
|
|
|
* parameter in this case. This can be handled by the
|
|
|
|
* drm_crtc_send_vblank_event() function, which the driver should call on
|
|
|
|
* the provided event upon completion of the flip. Note that if
|
|
|
|
* the driver supports vblank signalling and timestamping the vblank
|
|
|
|
* counters and timestamps must agree with the ones returned from page
|
|
|
|
* flip events. With the current vblank helper infrastructure this can
|
|
|
|
* be achieved by holding a vblank reference while the page flip is
|
|
|
|
* pending, acquired through drm_crtc_vblank_get() and released with
|
|
|
|
* drm_crtc_vblank_put(). Drivers are free to implement their own vblank
|
|
|
|
* counter and timestamp tracking though, e.g. if they have accurate
|
|
|
|
* timestamp registers in hardware.
|
|
|
|
*
|
|
|
|
* This callback is optional.
|
|
|
|
*
|
|
|
|
* NOTE:
|
|
|
|
*
|
|
|
|
* Very early versions of the KMS ABI mandated that the driver must
|
|
|
|
* block (but not reject) any rendering to the old framebuffer until the
|
|
|
|
* flip operation has completed and the old framebuffer is no longer
|
|
|
|
* visible. This requirement has been lifted, and userspace is instead
|
|
|
|
* expected to request delivery of an event and wait with recycling old
|
|
|
|
* buffers until such has been received.
|
|
|
|
*
|
|
|
|
* RETURNS:
|
|
|
|
*
|
|
|
|
* 0 on success or a negative error code on failure. Note that if a
|
2017-01-25 09:26:45 +03:00
|
|
|
* page flip operation is already pending the callback should return
|
2015-12-04 11:46:00 +03:00
|
|
|
* -EBUSY. Pageflips on a disabled CRTC (either by setting a NULL mode
|
|
|
|
* or just runtime disabled through DPMS respectively the new atomic
|
2015-12-08 11:49:20 +03:00
|
|
|
* "ACTIVE" state) should result in an -EINVAL error code. Note that
|
|
|
|
* drm_atomic_helper_page_flip() checks this already for atomic drivers.
|
2009-11-17 20:43:55 +03:00
|
|
|
*/
|
|
|
|
int (*page_flip)(struct drm_crtc *crtc,
|
|
|
|
struct drm_framebuffer *fb,
|
2013-07-23 05:49:58 +04:00
|
|
|
struct drm_pending_vblank_event *event,
|
2017-03-23 00:50:50 +03:00
|
|
|
uint32_t flags,
|
|
|
|
struct drm_modeset_acquire_ctx *ctx);
|
2012-05-16 01:09:05 +04:00
|
|
|
|
2016-08-08 10:23:03 +03:00
|
|
|
/**
|
|
|
|
* @page_flip_target:
|
|
|
|
*
|
|
|
|
* Same as @page_flip but with an additional parameter specifying the
|
|
|
|
* absolute target vertical blank period (as reported by
|
|
|
|
* drm_crtc_vblank_count()) when the flip should take effect.
|
|
|
|
*
|
|
|
|
* Note that the core code calls drm_crtc_vblank_get before this entry
|
|
|
|
* point, and will call drm_crtc_vblank_put if this entry point returns
|
|
|
|
* any non-0 error code. It's the driver's responsibility to call
|
|
|
|
* drm_crtc_vblank_put after this entry point returns 0, typically when
|
|
|
|
* the flip completes.
|
|
|
|
*/
|
|
|
|
int (*page_flip_target)(struct drm_crtc *crtc,
|
|
|
|
struct drm_framebuffer *fb,
|
|
|
|
struct drm_pending_vblank_event *event,
|
2017-03-23 00:50:50 +03:00
|
|
|
uint32_t flags, uint32_t target,
|
|
|
|
struct drm_modeset_acquire_ctx *ctx);
|
2016-08-08 10:23:03 +03:00
|
|
|
|
2015-12-04 11:45:48 +03:00
|
|
|
/**
|
|
|
|
* @set_property:
|
|
|
|
*
|
|
|
|
* This is the legacy entry point to update a property attached to the
|
|
|
|
* CRTC.
|
|
|
|
*
|
|
|
|
* This callback is optional if the driver does not support any legacy
|
2017-07-25 15:02:04 +03:00
|
|
|
* driver-private properties. For atomic drivers it is not used because
|
|
|
|
* property handling is done entirely in the DRM core.
|
2015-12-04 11:45:48 +03:00
|
|
|
*
|
|
|
|
* RETURNS:
|
|
|
|
*
|
|
|
|
* 0 on success or a negative error code on failure.
|
|
|
|
*/
|
2012-05-16 01:09:05 +04:00
|
|
|
int (*set_property)(struct drm_crtc *crtc,
|
|
|
|
struct drm_property *property, uint64_t val);
|
2014-10-27 22:28:44 +03:00
|
|
|
|
2015-12-04 11:45:48 +03:00
|
|
|
/**
|
|
|
|
* @atomic_duplicate_state:
|
|
|
|
*
|
|
|
|
* Duplicate the current atomic state for this CRTC and return it.
|
2017-01-25 09:26:45 +03:00
|
|
|
* The core and helpers guarantee that any atomic state duplicated with
|
2015-12-04 11:45:48 +03:00
|
|
|
* this hook and still owned by the caller (i.e. not transferred to the
|
2017-01-25 09:26:45 +03:00
|
|
|
* driver by calling &drm_mode_config_funcs.atomic_commit) will be
|
|
|
|
* cleaned up by calling the @atomic_destroy_state hook in this
|
|
|
|
* structure.
|
2015-12-04 11:45:48 +03:00
|
|
|
*
|
2018-05-25 04:25:55 +03:00
|
|
|
* This callback is mandatory for atomic drivers.
|
|
|
|
*
|
2017-01-25 09:26:45 +03:00
|
|
|
* Atomic drivers which don't subclass &struct drm_crtc_state should use
|
2015-12-04 11:45:48 +03:00
|
|
|
* drm_atomic_helper_crtc_duplicate_state(). Drivers that subclass the
|
|
|
|
* state structure to extend it with driver-private state should use
|
|
|
|
* __drm_atomic_helper_crtc_duplicate_state() to make sure shared state is
|
|
|
|
* duplicated in a consistent fashion across drivers.
|
|
|
|
*
|
2017-01-25 09:26:45 +03:00
|
|
|
* It is an error to call this hook before &drm_crtc.state has been
|
2015-12-04 11:45:48 +03:00
|
|
|
* initialized correctly.
|
|
|
|
*
|
|
|
|
* NOTE:
|
|
|
|
*
|
|
|
|
* If the duplicate state references refcounted resources this hook must
|
|
|
|
* acquire a reference for each of them. The driver must release these
|
|
|
|
* references again in @atomic_destroy_state.
|
|
|
|
*
|
|
|
|
* RETURNS:
|
|
|
|
*
|
|
|
|
* Duplicated atomic state or NULL when the allocation failed.
|
|
|
|
*/
|
2014-10-27 22:28:44 +03:00
|
|
|
struct drm_crtc_state *(*atomic_duplicate_state)(struct drm_crtc *crtc);
|
2015-12-04 11:45:48 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @atomic_destroy_state:
|
|
|
|
*
|
|
|
|
* Destroy a state duplicated with @atomic_duplicate_state and release
|
|
|
|
* or unreference all resources it references
|
2018-05-25 04:25:55 +03:00
|
|
|
*
|
|
|
|
* This callback is mandatory for atomic drivers.
|
2015-12-04 11:45:48 +03:00
|
|
|
*/
|
2014-10-27 22:28:44 +03:00
|
|
|
void (*atomic_destroy_state)(struct drm_crtc *crtc,
|
2014-07-25 23:30:38 +04:00
|
|
|
struct drm_crtc_state *state);
|
2015-12-04 11:45:48 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @atomic_set_property:
|
|
|
|
*
|
|
|
|
* Decode a driver-private property value and store the decoded value
|
|
|
|
* into the passed-in state structure. Since the atomic core decodes all
|
|
|
|
* standardized properties (even for extensions beyond the core set of
|
|
|
|
* properties which might not be implemented by all drivers) this
|
|
|
|
* requires drivers to subclass the state structure.
|
|
|
|
*
|
|
|
|
* Such driver-private properties should really only be implemented for
|
|
|
|
* truly hardware/vendor specific state. Instead it is preferred to
|
|
|
|
* standardize atomic extension and decode the properties used to expose
|
|
|
|
* such an extension in the core.
|
|
|
|
*
|
|
|
|
* Do not call this function directly, use
|
|
|
|
* drm_atomic_crtc_set_property() instead.
|
|
|
|
*
|
|
|
|
* This callback is optional if the driver does not support any
|
|
|
|
* driver-private atomic properties.
|
|
|
|
*
|
|
|
|
* NOTE:
|
|
|
|
*
|
|
|
|
* This function is called in the state assembly phase of atomic
|
|
|
|
* modesets, which can be aborted for any reason (including on
|
|
|
|
* userspace's request to just check whether a configuration would be
|
|
|
|
* possible). Drivers MUST NOT touch any persistent state (hardware or
|
|
|
|
* software) or data structures except the passed in @state parameter.
|
|
|
|
*
|
|
|
|
* Also since userspace controls in which order properties are set this
|
|
|
|
* function must not do any input validation (since the state update is
|
|
|
|
* incomplete and hence likely inconsistent). Instead any such input
|
|
|
|
* validation must be done in the various atomic_check callbacks.
|
|
|
|
*
|
|
|
|
* RETURNS:
|
|
|
|
*
|
|
|
|
* 0 if the property has been found, -EINVAL if the property isn't
|
|
|
|
* implemented by the driver (which should never happen, the core only
|
|
|
|
* asks for properties attached to this CRTC). No other validation is
|
|
|
|
* allowed by the driver. The core already checks that the property
|
|
|
|
* value is within the range (integer, valid enum value, ...) the driver
|
|
|
|
* set when registering the property.
|
|
|
|
*/
|
2014-10-27 22:28:44 +03:00
|
|
|
int (*atomic_set_property)(struct drm_crtc *crtc,
|
|
|
|
struct drm_crtc_state *state,
|
|
|
|
struct drm_property *property,
|
|
|
|
uint64_t val);
|
2015-12-04 11:45:48 +03:00
|
|
|
/**
|
|
|
|
* @atomic_get_property:
|
|
|
|
*
|
|
|
|
* Reads out the decoded driver-private property. This is used to
|
2015-12-04 11:46:01 +03:00
|
|
|
* implement the GETCRTC IOCTL.
|
2015-12-04 11:45:48 +03:00
|
|
|
*
|
|
|
|
* Do not call this function directly, use
|
|
|
|
* drm_atomic_crtc_get_property() instead.
|
|
|
|
*
|
|
|
|
* This callback is optional if the driver does not support any
|
|
|
|
* driver-private atomic properties.
|
|
|
|
*
|
|
|
|
* RETURNS:
|
|
|
|
*
|
|
|
|
* 0 on success, -EINVAL if the property isn't implemented by the
|
|
|
|
* driver (which should never happen, the core only asks for
|
|
|
|
* properties attached to this CRTC).
|
|
|
|
*/
|
2014-12-19 00:01:47 +03:00
|
|
|
int (*atomic_get_property)(struct drm_crtc *crtc,
|
|
|
|
const struct drm_crtc_state *state,
|
|
|
|
struct drm_property *property,
|
|
|
|
uint64_t *val);
|
2016-06-21 17:37:09 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @late_register:
|
|
|
|
*
|
|
|
|
* This optional hook can be used to register additional userspace
|
|
|
|
* interfaces attached to the crtc like debugfs interfaces.
|
|
|
|
* It is called late in the driver load sequence from drm_dev_register().
|
|
|
|
* Everything added from this callback should be unregistered in
|
|
|
|
* the early_unregister callback.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
*
|
|
|
|
* 0 on success, or a negative error code on failure.
|
|
|
|
*/
|
|
|
|
int (*late_register)(struct drm_crtc *crtc);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @early_unregister:
|
|
|
|
*
|
|
|
|
* This optional hook should be used to unregister the additional
|
|
|
|
* userspace interfaces attached to the crtc from
|
2017-01-25 09:26:55 +03:00
|
|
|
* @late_register. It is called from drm_dev_unregister(),
|
2016-06-21 17:37:09 +03:00
|
|
|
* early in the driver unload sequence to disable userspace access
|
|
|
|
* before data structures are torndown.
|
|
|
|
*/
|
|
|
|
void (*early_unregister)(struct drm_crtc *crtc);
|
2016-10-06 18:21:06 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @set_crc_source:
|
|
|
|
*
|
|
|
|
* Changes the source of CRC checksums of frames at the request of
|
|
|
|
* userspace, typically for testing purposes. The sources available are
|
|
|
|
* specific of each driver and a %NULL value indicates that CRC
|
|
|
|
* generation is to be switched off.
|
|
|
|
*
|
|
|
|
* When CRC generation is enabled, the driver should call
|
|
|
|
* drm_crtc_add_crc_entry() at each frame, providing any information
|
|
|
|
* that characterizes the frame contents in the crcN arguments, as
|
2017-03-22 11:36:04 +03:00
|
|
|
* provided from the configured source. Drivers must accept an "auto"
|
2016-10-06 18:21:06 +03:00
|
|
|
* source name that will select a default source for this CRTC.
|
|
|
|
*
|
2019-08-06 15:46:22 +03:00
|
|
|
* This may trigger an atomic modeset commit if necessary, to enable CRC
|
|
|
|
* generation.
|
|
|
|
*
|
2017-03-22 11:36:04 +03:00
|
|
|
* Note that "auto" can depend upon the current modeset configuration,
|
|
|
|
* e.g. it could pick an encoder or output specific CRC sampling point.
|
|
|
|
*
|
2016-10-06 18:21:06 +03:00
|
|
|
* This callback is optional if the driver does not support any CRC
|
|
|
|
* generation functionality.
|
|
|
|
*
|
|
|
|
* RETURNS:
|
|
|
|
*
|
|
|
|
* 0 on success or a negative error code on failure.
|
|
|
|
*/
|
2018-08-21 11:38:56 +03:00
|
|
|
int (*set_crc_source)(struct drm_crtc *crtc, const char *source);
|
2019-08-06 15:46:22 +03:00
|
|
|
|
2018-07-13 16:59:33 +03:00
|
|
|
/**
|
|
|
|
* @verify_crc_source:
|
|
|
|
*
|
|
|
|
* verifies the source of CRC checksums of frames before setting the
|
|
|
|
* source for CRC and during crc open. Source parameter can be NULL
|
|
|
|
* while disabling crc source.
|
|
|
|
*
|
|
|
|
* This callback is optional if the driver does not support any CRC
|
|
|
|
* generation functionality.
|
|
|
|
*
|
|
|
|
* RETURNS:
|
|
|
|
*
|
|
|
|
* 0 on success or a negative error code on failure.
|
|
|
|
*/
|
|
|
|
int (*verify_crc_source)(struct drm_crtc *crtc, const char *source,
|
|
|
|
size_t *values_cnt);
|
2018-07-13 16:59:34 +03:00
|
|
|
/**
|
|
|
|
* @get_crc_sources:
|
|
|
|
*
|
|
|
|
* Driver callback for getting a list of all the available sources for
|
|
|
|
* CRC generation. This callback depends upon verify_crc_source, So
|
|
|
|
* verify_crc_source callback should be implemented before implementing
|
|
|
|
* this. Driver can pass full list of available crc sources, this
|
|
|
|
* callback does the verification on each crc-source before passing it
|
|
|
|
* to userspace.
|
|
|
|
*
|
|
|
|
* This callback is optional if the driver does not support exporting of
|
|
|
|
* possible CRC sources list.
|
|
|
|
*
|
|
|
|
* RETURNS:
|
|
|
|
*
|
|
|
|
* a constant character pointer to the list of all the available CRC
|
|
|
|
* sources. On failure driver should return NULL. count should be
|
|
|
|
* updated with number of sources in list. if zero we don't process any
|
|
|
|
* source from the list.
|
|
|
|
*/
|
|
|
|
const char *const *(*get_crc_sources)(struct drm_crtc *crtc,
|
|
|
|
size_t *count);
|
2016-11-05 18:08:09 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @atomic_print_state:
|
|
|
|
*
|
2016-12-29 23:48:26 +03:00
|
|
|
* If driver subclasses &struct drm_crtc_state, it should implement
|
2016-11-05 18:08:09 +03:00
|
|
|
* this optional hook for printing additional driver specific state.
|
|
|
|
*
|
|
|
|
* Do not call this directly, use drm_atomic_crtc_print_state()
|
|
|
|
* instead.
|
|
|
|
*/
|
|
|
|
void (*atomic_print_state)(struct drm_printer *p,
|
|
|
|
const struct drm_crtc_state *state);
|
2017-02-07 12:16:13 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @get_vblank_counter:
|
|
|
|
*
|
|
|
|
* Driver callback for fetching a raw hardware vblank counter for the
|
|
|
|
* CRTC. It's meant to be used by new drivers as the replacement of
|
|
|
|
* &drm_driver.get_vblank_counter hook.
|
|
|
|
*
|
|
|
|
* This callback is optional. If a device doesn't have a hardware
|
|
|
|
* counter, the driver can simply leave the hook as NULL. The DRM core
|
|
|
|
* will account for missed vblank events while interrupts where disabled
|
|
|
|
* based on system timestamps.
|
|
|
|
*
|
|
|
|
* Wraparound handling and loss of events due to modesetting is dealt
|
|
|
|
* with in the DRM core code, as long as drivers call
|
|
|
|
* drm_crtc_vblank_off() and drm_crtc_vblank_on() when disabling or
|
|
|
|
* enabling a CRTC.
|
|
|
|
*
|
2017-05-24 17:51:45 +03:00
|
|
|
* See also &drm_device.vblank_disable_immediate and
|
|
|
|
* &drm_device.max_vblank_count.
|
|
|
|
*
|
2017-02-07 12:16:13 +03:00
|
|
|
* Returns:
|
|
|
|
*
|
|
|
|
* Raw vblank counter value.
|
|
|
|
*/
|
|
|
|
u32 (*get_vblank_counter)(struct drm_crtc *crtc);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @enable_vblank:
|
|
|
|
*
|
|
|
|
* Enable vblank interrupts for the CRTC. It's meant to be used by
|
|
|
|
* new drivers as the replacement of &drm_driver.enable_vblank hook.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
*
|
|
|
|
* Zero on success, appropriate errno if the vblank interrupt cannot
|
|
|
|
* be enabled.
|
|
|
|
*/
|
|
|
|
int (*enable_vblank)(struct drm_crtc *crtc);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @disable_vblank:
|
|
|
|
*
|
|
|
|
* Disable vblank interrupts for the CRTC. It's meant to be used by
|
|
|
|
* new drivers as the replacement of &drm_driver.disable_vblank hook.
|
|
|
|
*/
|
|
|
|
void (*disable_vblank)(struct drm_crtc *crtc);
|
2020-01-23 16:59:24 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @get_vblank_timestamp:
|
|
|
|
*
|
|
|
|
* Called by drm_get_last_vbltimestamp(). Should return a precise
|
|
|
|
* timestamp when the most recent vblank interval ended or will end.
|
|
|
|
*
|
|
|
|
* Specifically, the timestamp in @vblank_time should correspond as
|
|
|
|
* closely as possible to the time when the first video scanline of
|
|
|
|
* the video frame after the end of vblank will start scanning out,
|
|
|
|
* the time immediately after end of the vblank interval. If the
|
|
|
|
* @crtc is currently inside vblank, this will be a time in the future.
|
|
|
|
* If the @crtc is currently scanning out a frame, this will be the
|
|
|
|
* past start time of the current scanout. This is meant to adhere
|
|
|
|
* to the OpenML OML_sync_control extension specification.
|
|
|
|
*
|
|
|
|
* Parameters:
|
|
|
|
*
|
|
|
|
* crtc:
|
|
|
|
* CRTC for which timestamp should be returned.
|
|
|
|
* max_error:
|
|
|
|
* Maximum allowable timestamp error in nanoseconds.
|
|
|
|
* Implementation should strive to provide timestamp
|
|
|
|
* with an error of at most max_error nanoseconds.
|
|
|
|
* Returns true upper bound on error for timestamp.
|
|
|
|
* vblank_time:
|
|
|
|
* Target location for returned vblank timestamp.
|
|
|
|
* in_vblank_irq:
|
|
|
|
* True when called from drm_crtc_handle_vblank(). Some drivers
|
|
|
|
* need to apply some workarounds for gpu-specific vblank irq quirks
|
|
|
|
* if flag is set.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
*
|
|
|
|
* True on success, false on failure, which means the core should
|
|
|
|
* fallback to a simple timestamp taken in drm_crtc_handle_vblank().
|
|
|
|
*/
|
|
|
|
bool (*get_vblank_timestamp)(struct drm_crtc *crtc,
|
|
|
|
int *max_error,
|
|
|
|
ktime_t *vblank_time,
|
|
|
|
bool in_vblank_irq);
|
2008-11-08 01:05:41 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
2014-10-27 18:54:27 +03:00
|
|
|
* struct drm_crtc - central CRTC control structure
|
2008-11-08 01:05:41 +03:00
|
|
|
*
|
|
|
|
* Each CRTC may have one or more connectors associated with it. This structure
|
|
|
|
* allows the CRTC to be controlled.
|
|
|
|
*/
|
|
|
|
struct drm_crtc {
|
2018-07-09 11:40:12 +03:00
|
|
|
/** @dev: parent DRM device */
|
2008-11-08 01:05:41 +03:00
|
|
|
struct drm_device *dev;
|
2018-07-09 11:40:12 +03:00
|
|
|
/** @port: OF node used by drm_of_find_possible_crtcs(). */
|
2014-06-15 14:07:12 +04:00
|
|
|
struct device_node *port;
|
2018-07-09 11:40:12 +03:00
|
|
|
/**
|
|
|
|
* @head:
|
|
|
|
*
|
|
|
|
* List of all CRTCs on @dev, linked from &drm_mode_config.crtc_list.
|
|
|
|
* Invariant over the lifetime of @dev and therefore does not need
|
|
|
|
* locking.
|
|
|
|
*/
|
2008-11-08 01:05:41 +03:00
|
|
|
struct list_head head;
|
|
|
|
|
2018-07-09 11:40:12 +03:00
|
|
|
/** @name: human readable name, can be overwritten by the driver */
|
2015-12-08 19:41:53 +03:00
|
|
|
char *name;
|
|
|
|
|
2016-06-01 00:11:10 +03:00
|
|
|
/**
|
|
|
|
* @mutex:
|
drm: add per-crtc locks
*drumroll*
The basic idea is to protect per-crtc state which can change without
touching the output configuration with separate mutexes, i.e. all the
input side state to a crtc like framebuffers, cursor settings or plane
configuration. Holding such a crtc lock gives a read-lock on all the
other crtc state which can be changed by e.g. a modeset.
All non-crtc state is still protected by the mode_config mutex.
Callers that need to change modeset state of a crtc (e.g. dpms or
set_mode) need to grab both the mode_config lock and nested within any
crtc locks.
Note that since there can only ever be one holder of the mode_config
lock we can grab the subordinate crtc locks in any order (if we need
to grab more than one of them). Lockdep can handle such nesting with
the mutex_lock_nest_lock call correctly.
With this functions that only touch connectors/encoders but not crtcs
only need to take the mode_config lock. The biggest such case is the
output probing, which means that we can now pageflip and move cursors
while the output probe code is reading an edid.
Most cases neatly fall into the three buckets:
- Only touches connectors and similar output state and so only needs
the mode_config lock.
- Touches the global configuration and so needs all locks.
- Only touches the crtc input side and so only needs the crtc lock.
But a few cases that need special consideration:
- Load detection which requires a crtc. The mode_config lock already
prevents a modeset change, so we can use any unused crtc as we like
to do load detection. The only thing to consider is that such
temporary state changes don't leak out to userspace through ioctls
that only take the crtc look (like a pageflip). Hence the load
detect code needs to grab the crtc of any output pipes it touches
(but only if it touches state used by the pageflip or cursor
ioctls).
- Atomic pageflip when moving planes. The first case is sane hw, where
planes have a fixed association with crtcs - nothing needs to be
done there. More insane^Wflexible hw needs to have plane->crtc
mapping which is separately protect with a lock that nests within
the crtc lock. If the plane is unused we can just assign it to the
current crtc and continue. But if a plane is already in use by
another crtc we can't just reassign it.
Two solution present themselves: Either go back to a slow-path which
takes all modeset locks, potentially incure quite a hefty delay. Or
simply disallowing such changes in one atomic pageflip - in general
the vblanks of two crtcs are not synced, so there's no sane way to
atomically flip such plane changes accross more than one crtc. I'd
heavily favour the later approach, going as far as mandating it as
part of the ABI of such a new a nuclear pageflip.
And if we _really_ want such semantics, we can always get them by
introducing another pageflip mutex between the mode_config.mutex and
the individual crtc locks. Pageflips crossing more than one crtc
would then need to take that lock first, to lock out concurrent
multi-crtc pageflips.
- Optimized global modeset operations: We could just take the
mode_config lock and then lazily lock all crtc which are affected by
a modeset operation. This has the advantage that pageflip could
continue unhampered on unaffected crtc. But if e.g. global resources
like plls need to be reassigned and so affect unrelated crtcs we can
still do that - nested locking works in any order.
This patch just adds the locks and takes them in drm_modeset_lock_all,
no real locking changes yet.
v2: Need to initialize the new lock in crtc_init and lock it righ
away, for otherwise the modeset_unlock_all below will try to unlock a
not-locked mutex.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-02 05:18:25 +04:00
|
|
|
*
|
2017-03-28 18:53:48 +03:00
|
|
|
* This provides a read lock for the overall CRTC state (mode, dpms
|
drm: add per-crtc locks
*drumroll*
The basic idea is to protect per-crtc state which can change without
touching the output configuration with separate mutexes, i.e. all the
input side state to a crtc like framebuffers, cursor settings or plane
configuration. Holding such a crtc lock gives a read-lock on all the
other crtc state which can be changed by e.g. a modeset.
All non-crtc state is still protected by the mode_config mutex.
Callers that need to change modeset state of a crtc (e.g. dpms or
set_mode) need to grab both the mode_config lock and nested within any
crtc locks.
Note that since there can only ever be one holder of the mode_config
lock we can grab the subordinate crtc locks in any order (if we need
to grab more than one of them). Lockdep can handle such nesting with
the mutex_lock_nest_lock call correctly.
With this functions that only touch connectors/encoders but not crtcs
only need to take the mode_config lock. The biggest such case is the
output probing, which means that we can now pageflip and move cursors
while the output probe code is reading an edid.
Most cases neatly fall into the three buckets:
- Only touches connectors and similar output state and so only needs
the mode_config lock.
- Touches the global configuration and so needs all locks.
- Only touches the crtc input side and so only needs the crtc lock.
But a few cases that need special consideration:
- Load detection which requires a crtc. The mode_config lock already
prevents a modeset change, so we can use any unused crtc as we like
to do load detection. The only thing to consider is that such
temporary state changes don't leak out to userspace through ioctls
that only take the crtc look (like a pageflip). Hence the load
detect code needs to grab the crtc of any output pipes it touches
(but only if it touches state used by the pageflip or cursor
ioctls).
- Atomic pageflip when moving planes. The first case is sane hw, where
planes have a fixed association with crtcs - nothing needs to be
done there. More insane^Wflexible hw needs to have plane->crtc
mapping which is separately protect with a lock that nests within
the crtc lock. If the plane is unused we can just assign it to the
current crtc and continue. But if a plane is already in use by
another crtc we can't just reassign it.
Two solution present themselves: Either go back to a slow-path which
takes all modeset locks, potentially incure quite a hefty delay. Or
simply disallowing such changes in one atomic pageflip - in general
the vblanks of two crtcs are not synced, so there's no sane way to
atomically flip such plane changes accross more than one crtc. I'd
heavily favour the later approach, going as far as mandating it as
part of the ABI of such a new a nuclear pageflip.
And if we _really_ want such semantics, we can always get them by
introducing another pageflip mutex between the mode_config.mutex and
the individual crtc locks. Pageflips crossing more than one crtc
would then need to take that lock first, to lock out concurrent
multi-crtc pageflips.
- Optimized global modeset operations: We could just take the
mode_config lock and then lazily lock all crtc which are affected by
a modeset operation. This has the advantage that pageflip could
continue unhampered on unaffected crtc. But if e.g. global resources
like plls need to be reassigned and so affect unrelated crtcs we can
still do that - nested locking works in any order.
This patch just adds the locks and takes them in drm_modeset_lock_all,
no real locking changes yet.
v2: Need to initialize the new lock in crtc_init and lock it righ
away, for otherwise the modeset_unlock_all below will try to unlock a
not-locked mutex.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-02 05:18:25 +04:00
|
|
|
* state, ...) and a write lock for everything which can be update
|
2017-03-28 18:53:48 +03:00
|
|
|
* without a full modeset (fb, cursor data, CRTC properties ...). A full
|
2017-01-25 09:26:45 +03:00
|
|
|
* modeset also need to grab &drm_mode_config.connection_mutex.
|
2017-03-28 18:53:48 +03:00
|
|
|
*
|
|
|
|
* For atomic drivers specifically this protects @state.
|
drm: add per-crtc locks
*drumroll*
The basic idea is to protect per-crtc state which can change without
touching the output configuration with separate mutexes, i.e. all the
input side state to a crtc like framebuffers, cursor settings or plane
configuration. Holding such a crtc lock gives a read-lock on all the
other crtc state which can be changed by e.g. a modeset.
All non-crtc state is still protected by the mode_config mutex.
Callers that need to change modeset state of a crtc (e.g. dpms or
set_mode) need to grab both the mode_config lock and nested within any
crtc locks.
Note that since there can only ever be one holder of the mode_config
lock we can grab the subordinate crtc locks in any order (if we need
to grab more than one of them). Lockdep can handle such nesting with
the mutex_lock_nest_lock call correctly.
With this functions that only touch connectors/encoders but not crtcs
only need to take the mode_config lock. The biggest such case is the
output probing, which means that we can now pageflip and move cursors
while the output probe code is reading an edid.
Most cases neatly fall into the three buckets:
- Only touches connectors and similar output state and so only needs
the mode_config lock.
- Touches the global configuration and so needs all locks.
- Only touches the crtc input side and so only needs the crtc lock.
But a few cases that need special consideration:
- Load detection which requires a crtc. The mode_config lock already
prevents a modeset change, so we can use any unused crtc as we like
to do load detection. The only thing to consider is that such
temporary state changes don't leak out to userspace through ioctls
that only take the crtc look (like a pageflip). Hence the load
detect code needs to grab the crtc of any output pipes it touches
(but only if it touches state used by the pageflip or cursor
ioctls).
- Atomic pageflip when moving planes. The first case is sane hw, where
planes have a fixed association with crtcs - nothing needs to be
done there. More insane^Wflexible hw needs to have plane->crtc
mapping which is separately protect with a lock that nests within
the crtc lock. If the plane is unused we can just assign it to the
current crtc and continue. But if a plane is already in use by
another crtc we can't just reassign it.
Two solution present themselves: Either go back to a slow-path which
takes all modeset locks, potentially incure quite a hefty delay. Or
simply disallowing such changes in one atomic pageflip - in general
the vblanks of two crtcs are not synced, so there's no sane way to
atomically flip such plane changes accross more than one crtc. I'd
heavily favour the later approach, going as far as mandating it as
part of the ABI of such a new a nuclear pageflip.
And if we _really_ want such semantics, we can always get them by
introducing another pageflip mutex between the mode_config.mutex and
the individual crtc locks. Pageflips crossing more than one crtc
would then need to take that lock first, to lock out concurrent
multi-crtc pageflips.
- Optimized global modeset operations: We could just take the
mode_config lock and then lazily lock all crtc which are affected by
a modeset operation. This has the advantage that pageflip could
continue unhampered on unaffected crtc. But if e.g. global resources
like plls need to be reassigned and so affect unrelated crtcs we can
still do that - nested locking works in any order.
This patch just adds the locks and takes them in drm_modeset_lock_all,
no real locking changes yet.
v2: Need to initialize the new lock in crtc_init and lock it righ
away, for otherwise the modeset_unlock_all below will try to unlock a
not-locked mutex.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-02 05:18:25 +04:00
|
|
|
*/
|
2013-11-19 21:10:12 +04:00
|
|
|
struct drm_modeset_lock mutex;
|
drm: add per-crtc locks
*drumroll*
The basic idea is to protect per-crtc state which can change without
touching the output configuration with separate mutexes, i.e. all the
input side state to a crtc like framebuffers, cursor settings or plane
configuration. Holding such a crtc lock gives a read-lock on all the
other crtc state which can be changed by e.g. a modeset.
All non-crtc state is still protected by the mode_config mutex.
Callers that need to change modeset state of a crtc (e.g. dpms or
set_mode) need to grab both the mode_config lock and nested within any
crtc locks.
Note that since there can only ever be one holder of the mode_config
lock we can grab the subordinate crtc locks in any order (if we need
to grab more than one of them). Lockdep can handle such nesting with
the mutex_lock_nest_lock call correctly.
With this functions that only touch connectors/encoders but not crtcs
only need to take the mode_config lock. The biggest such case is the
output probing, which means that we can now pageflip and move cursors
while the output probe code is reading an edid.
Most cases neatly fall into the three buckets:
- Only touches connectors and similar output state and so only needs
the mode_config lock.
- Touches the global configuration and so needs all locks.
- Only touches the crtc input side and so only needs the crtc lock.
But a few cases that need special consideration:
- Load detection which requires a crtc. The mode_config lock already
prevents a modeset change, so we can use any unused crtc as we like
to do load detection. The only thing to consider is that such
temporary state changes don't leak out to userspace through ioctls
that only take the crtc look (like a pageflip). Hence the load
detect code needs to grab the crtc of any output pipes it touches
(but only if it touches state used by the pageflip or cursor
ioctls).
- Atomic pageflip when moving planes. The first case is sane hw, where
planes have a fixed association with crtcs - nothing needs to be
done there. More insane^Wflexible hw needs to have plane->crtc
mapping which is separately protect with a lock that nests within
the crtc lock. If the plane is unused we can just assign it to the
current crtc and continue. But if a plane is already in use by
another crtc we can't just reassign it.
Two solution present themselves: Either go back to a slow-path which
takes all modeset locks, potentially incure quite a hefty delay. Or
simply disallowing such changes in one atomic pageflip - in general
the vblanks of two crtcs are not synced, so there's no sane way to
atomically flip such plane changes accross more than one crtc. I'd
heavily favour the later approach, going as far as mandating it as
part of the ABI of such a new a nuclear pageflip.
And if we _really_ want such semantics, we can always get them by
introducing another pageflip mutex between the mode_config.mutex and
the individual crtc locks. Pageflips crossing more than one crtc
would then need to take that lock first, to lock out concurrent
multi-crtc pageflips.
- Optimized global modeset operations: We could just take the
mode_config lock and then lazily lock all crtc which are affected by
a modeset operation. This has the advantage that pageflip could
continue unhampered on unaffected crtc. But if e.g. global resources
like plls need to be reassigned and so affect unrelated crtcs we can
still do that - nested locking works in any order.
This patch just adds the locks and takes them in drm_modeset_lock_all,
no real locking changes yet.
v2: Need to initialize the new lock in crtc_init and lock it righ
away, for otherwise the modeset_unlock_all below will try to unlock a
not-locked mutex.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-02 05:18:25 +04:00
|
|
|
|
2018-07-09 11:40:12 +03:00
|
|
|
/** @base: base KMS object for ID tracking etc. */
|
2008-11-08 01:05:41 +03:00
|
|
|
struct drm_mode_object base;
|
|
|
|
|
2018-07-09 11:40:12 +03:00
|
|
|
/**
|
|
|
|
* @primary:
|
|
|
|
* Primary plane for this CRTC. Note that this is only
|
|
|
|
* relevant for legacy IOCTL, it specifies the plane implicitly used by
|
|
|
|
* the SETCRTC and PAGE_FLIP IOCTLs. It does not have any significance
|
|
|
|
* beyond that.
|
|
|
|
*/
|
2014-04-02 02:22:38 +04:00
|
|
|
struct drm_plane *primary;
|
2018-07-09 11:40:12 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @cursor:
|
|
|
|
* Cursor plane for this CRTC. Note that this is only relevant for
|
|
|
|
* legacy IOCTL, it specifies the plane implicitly used by the SETCURSOR
|
|
|
|
* and SETCURSOR2 IOCTLs. It does not have any significance
|
|
|
|
* beyond that.
|
|
|
|
*/
|
2014-04-02 02:22:38 +04:00
|
|
|
struct drm_plane *cursor;
|
|
|
|
|
2016-07-15 22:47:59 +03:00
|
|
|
/**
|
|
|
|
* @index: Position inside the mode_config.list, can be used as an array
|
|
|
|
* index. It is invariant over the lifetime of the CRTC.
|
|
|
|
*/
|
2016-05-27 22:05:00 +03:00
|
|
|
unsigned index;
|
|
|
|
|
2018-07-09 11:40:12 +03:00
|
|
|
/**
|
|
|
|
* @cursor_x: Current x position of the cursor, used for universal
|
|
|
|
* cursor planes because the SETCURSOR IOCTL only can update the
|
|
|
|
* framebuffer without supplying the coordinates. Drivers should not use
|
|
|
|
* this directly, atomic drivers should look at &drm_plane_state.crtc_x
|
|
|
|
* of the cursor plane instead.
|
|
|
|
*/
|
2014-06-10 19:28:10 +04:00
|
|
|
int cursor_x;
|
2018-07-09 11:40:12 +03:00
|
|
|
/**
|
|
|
|
* @cursor_y: Current y position of the cursor, used for universal
|
|
|
|
* cursor planes because the SETCURSOR IOCTL only can update the
|
|
|
|
* framebuffer without supplying the coordinates. Drivers should not use
|
|
|
|
* this directly, atomic drivers should look at &drm_plane_state.crtc_y
|
|
|
|
* of the cursor plane instead.
|
|
|
|
*/
|
2014-06-10 19:28:10 +04:00
|
|
|
int cursor_y;
|
|
|
|
|
2018-07-09 11:40:12 +03:00
|
|
|
/**
|
|
|
|
* @enabled:
|
|
|
|
*
|
|
|
|
* Is this CRTC enabled? Should only be used by legacy drivers, atomic
|
|
|
|
* drivers should instead consult &drm_crtc_state.enable and
|
|
|
|
* &drm_crtc_state.active. Atomic drivers can update this by calling
|
|
|
|
* drm_atomic_helper_update_legacy_modeset_state().
|
|
|
|
*/
|
2008-11-08 01:05:41 +03:00
|
|
|
bool enabled;
|
|
|
|
|
2018-07-09 11:40:12 +03:00
|
|
|
/**
|
|
|
|
* @mode:
|
|
|
|
*
|
|
|
|
* Current mode timings. Should only be used by legacy drivers, atomic
|
|
|
|
* drivers should instead consult &drm_crtc_state.mode. Atomic drivers
|
|
|
|
* can update this by calling
|
|
|
|
* drm_atomic_helper_update_legacy_modeset_state().
|
|
|
|
*/
|
2008-11-08 01:05:41 +03:00
|
|
|
struct drm_display_mode mode;
|
|
|
|
|
2018-07-09 11:40:12 +03:00
|
|
|
/**
|
|
|
|
* @hwmode:
|
|
|
|
*
|
|
|
|
* Programmed mode in hw, after adjustments for encoders, crtc, panel
|
|
|
|
* scaling etc. Should only be used by legacy drivers, for high
|
|
|
|
* precision vblank timestamps in
|
2020-01-23 16:59:24 +03:00
|
|
|
* drm_crtc_vblank_helper_get_vblank_timestamp().
|
2018-07-09 11:40:12 +03:00
|
|
|
*
|
|
|
|
* Note that atomic drivers should not use this, but instead use
|
|
|
|
* &drm_crtc_state.adjusted_mode. And for high-precision timestamps
|
2020-01-23 16:59:24 +03:00
|
|
|
* drm_crtc_vblank_helper_get_vblank_timestamp() used
|
|
|
|
* &drm_vblank_crtc.hwmode,
|
2018-07-09 11:40:12 +03:00
|
|
|
* which is filled out by calling drm_calc_timestamping_constants().
|
drm/vblank: Add support for precise vblank timestamping.
The DRI2 swap & sync implementation needs precise
vblank counts and precise timestamps corresponding
to those vblank counts. For conformance to the OpenML
OML_sync_control extension specification the DRM
timestamp associated with a vblank count should
correspond to the start of video scanout of the first
scanline of the video frame following the vblank
interval for that vblank count.
Therefore we need to carry around precise timestamps
for vblanks. Currently the DRM and KMS drivers generate
timestamps ad-hoc via do_gettimeofday() in some
places. The resulting timestamps are sometimes not
very precise due to interrupt handling delays, they
don't conform to OML_sync_control and some are wrong,
as they aren't taken synchronized to the vblank.
This patch implements support inside the drm core
for precise and robust timestamping. It consists
of the following interrelated pieces.
1. Vblank timestamp caching:
A per-crtc ringbuffer stores the most recent vblank
timestamps corresponding to vblank counts.
The ringbuffer can be read out lock-free via the
accessor function:
struct timeval timestamp;
vblankcount = drm_vblank_count_and_time(dev, crtcid, ×tamp).
The function returns the current vblank count and
the corresponding timestamp for start of video
scanout following the vblank interval. It can be
used anywhere between enclosing drm_vblank_get(dev, crtcid)
and drm_vblank_put(dev,crtcid) statements. It is used
inside the drmWaitVblank ioctl and in the vblank event
queueing and handling. It should be used by kms drivers for
timestamping of bufferswap completion.
The timestamp ringbuffer is reinitialized each time
vblank irq's get reenabled in drm_vblank_get()/
drm_update_vblank_count(). It is invalidated when
vblank irq's get disabled.
The ringbuffer is updated inside drm_handle_vblank()
at each vblank irq.
2. Calculation of precise vblank timestamps:
drm_get_last_vbltimestamp() is used to compute the
timestamp for the end of the most recent vblank (if
inside active scanout), or the expected end of the
current vblank interval (if called inside a vblank
interval). The function calls into a new optional kms
driver entry point dev->driver->get_vblank_timestamp()
which is supposed to provide the precise timestamp.
If a kms driver doesn't implement the entry point or
if the call fails, a simple do_gettimeofday() timestamp
is returned as crude approximation of the true vblank time.
A new drm module parameter drm.timestamp_precision_usec
allows to disable high precision timestamps (if set to
zero) or to specify the maximum acceptable error in
the timestamps in microseconds.
Kms drivers could implement their get_vblank_timestamp()
function in a gpu specific way, as long as returned
timestamps conform to OML_sync_control, e.g., by use
of gpu specific hardware timestamps.
Optionally, kms drivers can simply wrap and use the new
utility function drm_calc_vbltimestamp_from_scanoutpos().
This function calls a new optional kms driver function
dev->driver->get_scanout_position() which returns the
current horizontal and vertical video scanout position
of the crtc. The scanout position together with the
drm_display_timing of the current video mode is used
to calculate elapsed time relative to start of active scanout
for the current video frame. This elapsed time is subtracted
from the current do_gettimeofday() time to get the timestamp
corresponding to start of video scanout. Currently
non-interlaced, non-doublescan video modes, with or
without panel scaling are handled correctly. Interlaced/
doublescan modes are tbd in a future patch.
3. Filtering of redundant vblank irq's and removal of
some race-conditions in the vblank irq enable/disable path:
Some gpu's (e.g., Radeon R500/R600) send spurious vblank
irq's outside the vblank if vblank irq's get reenabled.
These get detected by use of the vblank timestamps and
filtered out to avoid miscounting of vblanks.
Some race-conditions between the vblank irq enable/disable
functions, the vblank irq handler and the gpu itself (updating
its hardware vblank counter in the "wrong" moment) are
fixed inside vblank_disable_and_save() and
drm_update_vblank_count() by use of the vblank timestamps and
a new spinlock dev->vblank_time_lock.
The time until vblank irq disable is now configurable via
a new drm module parameter drm.vblankoffdelay to allow
experimentation with timeouts that are much shorter than
the current 5 seconds and should allow longer vblank off
periods for better power savings.
Followup patches will use these new functions to
implement precise timestamping for the intel and radeon
kms drivers.
Signed-off-by: Mario Kleiner <mario.kleiner@tuebingen.mpg.de>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2010-10-23 06:20:23 +04:00
|
|
|
*/
|
|
|
|
struct drm_display_mode hwmode;
|
|
|
|
|
2018-07-09 11:40:12 +03:00
|
|
|
/**
|
|
|
|
* @x:
|
|
|
|
* x position on screen. Should only be used by legacy drivers, atomic
|
|
|
|
* drivers should look at &drm_plane_state.crtc_x of the primary plane
|
|
|
|
* instead. Updated by calling
|
|
|
|
* drm_atomic_helper_update_legacy_modeset_state().
|
|
|
|
*/
|
|
|
|
int x;
|
|
|
|
/**
|
|
|
|
* @y:
|
|
|
|
* y position on screen. Should only be used by legacy drivers, atomic
|
|
|
|
* drivers should look at &drm_plane_state.crtc_y of the primary plane
|
|
|
|
* instead. Updated by calling
|
|
|
|
* drm_atomic_helper_update_legacy_modeset_state().
|
|
|
|
*/
|
|
|
|
int y;
|
|
|
|
|
|
|
|
/** @funcs: CRTC control functions */
|
2008-11-08 01:05:41 +03:00
|
|
|
const struct drm_crtc_funcs *funcs;
|
|
|
|
|
2018-07-09 11:40:12 +03:00
|
|
|
/**
|
|
|
|
* @gamma_size: Size of legacy gamma ramp reported to userspace. Set up
|
|
|
|
* by calling drm_mode_crtc_set_gamma_size().
|
|
|
|
*/
|
2008-11-08 01:05:41 +03:00
|
|
|
uint32_t gamma_size;
|
2018-07-09 11:40:12 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @gamma_store: Gamma ramp values used by the legacy SETGAMMA and
|
|
|
|
* GETGAMMA IOCTls. Set up by calling drm_mode_crtc_set_gamma_size().
|
|
|
|
*/
|
2008-11-08 01:05:41 +03:00
|
|
|
uint16_t *gamma_store;
|
|
|
|
|
2018-07-09 11:40:12 +03:00
|
|
|
/** @helper_private: mid-layer private data */
|
2015-12-04 11:45:45 +03:00
|
|
|
const struct drm_crtc_helper_funcs *helper_private;
|
2012-05-16 01:09:05 +04:00
|
|
|
|
2018-07-09 11:40:12 +03:00
|
|
|
/** @properties: property tracking for this CRTC */
|
2012-05-16 01:09:05 +04:00
|
|
|
struct drm_object_properties properties;
|
2014-07-25 20:07:40 +04:00
|
|
|
|
2016-06-08 15:19:00 +03:00
|
|
|
/**
|
|
|
|
* @state:
|
|
|
|
*
|
|
|
|
* Current atomic state for this CRTC.
|
2017-03-28 18:53:48 +03:00
|
|
|
*
|
|
|
|
* This is protected by @mutex. Note that nonblocking atomic commits
|
|
|
|
* access the current CRTC state without taking locks. Either by going
|
|
|
|
* through the &struct drm_atomic_state pointers, see
|
2017-07-19 17:39:20 +03:00
|
|
|
* for_each_oldnew_crtc_in_state(), for_each_old_crtc_in_state() and
|
|
|
|
* for_each_new_crtc_in_state(). Or through careful ordering of atomic
|
|
|
|
* commit operations as implemented in the atomic helpers, see
|
|
|
|
* &struct drm_crtc_commit.
|
2016-06-08 15:19:00 +03:00
|
|
|
*/
|
2014-10-27 22:28:44 +03:00
|
|
|
struct drm_crtc_state *state;
|
|
|
|
|
2016-06-08 15:19:00 +03:00
|
|
|
/**
|
|
|
|
* @commit_list:
|
|
|
|
*
|
|
|
|
* List of &drm_crtc_commit structures tracking pending commits.
|
2017-09-04 18:04:56 +03:00
|
|
|
* Protected by @commit_lock. This list holds its own full reference,
|
|
|
|
* as does the ongoing commit.
|
|
|
|
*
|
|
|
|
* "Note that the commit for a state change is also tracked in
|
|
|
|
* &drm_crtc_state.commit. For accessing the immediately preceding
|
|
|
|
* commit in an atomic update it is recommended to just use that
|
|
|
|
* pointer in the old CRTC state, since accessing that doesn't need
|
|
|
|
* any locking or list-walking. @commit_list should only be used to
|
|
|
|
* stall for framebuffer cleanup that's signalled through
|
|
|
|
* &drm_crtc_commit.cleanup_done."
|
2016-06-08 15:19:00 +03:00
|
|
|
*/
|
|
|
|
struct list_head commit_list;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @commit_lock:
|
|
|
|
*
|
|
|
|
* Spinlock to protect @commit_list.
|
|
|
|
*/
|
|
|
|
spinlock_t commit_lock;
|
|
|
|
|
2016-10-06 18:21:06 +03:00
|
|
|
#ifdef CONFIG_DEBUG_FS
|
|
|
|
/**
|
|
|
|
* @debugfs_entry:
|
|
|
|
*
|
|
|
|
* Debugfs directory for this CRTC.
|
|
|
|
*/
|
|
|
|
struct dentry *debugfs_entry;
|
2017-03-06 23:00:17 +03:00
|
|
|
#endif
|
2016-10-06 18:21:06 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @crc:
|
|
|
|
*
|
|
|
|
* Configuration settings of CRC capture.
|
|
|
|
*/
|
|
|
|
struct drm_crtc_crc crc;
|
2016-11-15 17:37:08 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @fence_context:
|
|
|
|
*
|
|
|
|
* timeline context used for fence operations.
|
|
|
|
*/
|
|
|
|
unsigned int fence_context;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @fence_lock:
|
|
|
|
*
|
|
|
|
* spinlock to protect the fences in the fence_context.
|
|
|
|
*/
|
|
|
|
spinlock_t fence_lock;
|
|
|
|
/**
|
|
|
|
* @fence_seqno:
|
|
|
|
*
|
|
|
|
* Seqno variable used as monotonic counter for the fences
|
|
|
|
* created on the CRTC's timeline.
|
|
|
|
*/
|
|
|
|
unsigned long fence_seqno;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @timeline_name:
|
|
|
|
*
|
|
|
|
* The name of the CRTC's fence timeline.
|
|
|
|
*/
|
|
|
|
char timeline_name[32];
|
2019-06-12 17:50:19 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @self_refresh_data: Holds the state for the self refresh helpers
|
|
|
|
*
|
2019-09-18 23:07:28 +03:00
|
|
|
* Initialized via drm_self_refresh_helper_init().
|
2019-06-12 17:50:19 +03:00
|
|
|
*/
|
|
|
|
struct drm_self_refresh_data *self_refresh_data;
|
2008-11-08 01:05:41 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
2014-10-27 18:54:27 +03:00
|
|
|
* struct drm_mode_set - new values for a CRTC config change
|
2011-11-08 00:03:19 +04:00
|
|
|
* @fb: framebuffer to use for new config
|
|
|
|
* @crtc: CRTC whose configuration we're about to change
|
|
|
|
* @mode: mode timings to use
|
|
|
|
* @x: position of this CRTC relative to @fb
|
|
|
|
* @y: position of this CRTC relative to @fb
|
|
|
|
* @connectors: array of connectors to drive with this CRTC if possible
|
|
|
|
* @num_connectors: size of @connectors array
|
2008-11-08 01:05:41 +03:00
|
|
|
*
|
2017-01-25 09:26:57 +03:00
|
|
|
* This represents a modeset configuration for the legacy SETCRTC ioctl and is
|
|
|
|
* also used internally. Atomic drivers instead use &drm_atomic_state.
|
2008-11-08 01:05:41 +03:00
|
|
|
*/
|
|
|
|
struct drm_mode_set {
|
|
|
|
struct drm_framebuffer *fb;
|
|
|
|
struct drm_crtc *crtc;
|
|
|
|
struct drm_display_mode *mode;
|
|
|
|
|
|
|
|
uint32_t x;
|
|
|
|
uint32_t y;
|
|
|
|
|
|
|
|
struct drm_connector **connectors;
|
|
|
|
size_t num_connectors;
|
|
|
|
};
|
|
|
|
|
|
|
|
#define obj_to_crtc(x) container_of(x, struct drm_crtc, base)
|
|
|
|
|
2016-11-14 14:58:25 +03:00
|
|
|
__printf(6, 7)
|
drm: Pass 'name' to drm_crtc_init_with_planes()
Done with coccinelle for the most part. However, it thinks '...' is
part of the semantic patch, so I put an 'int DOTDOTDOT' placeholder
in its place and got rid of it with sed afterwards.
I didn't convert drm_crtc_init() since passing the varargs through
would mean either cpp macros or va_list, and I figured we don't
care about these legacy functions enough to warrant the extra pain.
@@
identifier dev, crtc, primary, cursor, funcs;
@@
int drm_crtc_init_with_planes(struct drm_device *dev,
struct drm_crtc *crtc,
struct drm_plane *primary, struct drm_plane *cursor,
const struct drm_crtc_funcs *funcs
+ ,const char *name, int DOTDOTDOT
)
{ ... }
@@
identifier dev, crtc, primary, cursor, funcs;
@@
int drm_crtc_init_with_planes(struct drm_device *dev,
struct drm_crtc *crtc,
struct drm_plane *primary, struct drm_plane *cursor,
const struct drm_crtc_funcs *funcs
+ ,const char *name, int DOTDOTDOT
);
@@
expression E1, E2, E3, E4, E5;
@@
drm_crtc_init_with_planes(E1, E2, E3, E4, E5
+ ,NULL
)
v2: Split crtc and plane changes apart
Pass NULL for no-name instead of ""
Leave drm_crtc_init() alone
v3: Add ', or NULL...' to @name kernel doc (Jani)
Annotate the function with __printf() attribute (Jani)
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Link: http://patchwork.freedesktop.org/patch/msgid/1449670771-2751-1-git-send-email-ville.syrjala@linux.intel.com
2015-12-09 17:19:31 +03:00
|
|
|
int drm_crtc_init_with_planes(struct drm_device *dev,
|
|
|
|
struct drm_crtc *crtc,
|
|
|
|
struct drm_plane *primary,
|
|
|
|
struct drm_plane *cursor,
|
|
|
|
const struct drm_crtc_funcs *funcs,
|
|
|
|
const char *name, ...);
|
2016-11-14 14:58:25 +03:00
|
|
|
void drm_crtc_cleanup(struct drm_crtc *crtc);
|
2016-05-27 22:05:00 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_crtc_index - find the index of a registered CRTC
|
|
|
|
* @crtc: CRTC to find index for
|
|
|
|
*
|
|
|
|
* Given a registered CRTC, return the index of that CRTC within a DRM
|
|
|
|
* device's list of CRTCs.
|
|
|
|
*/
|
2016-10-10 18:26:10 +03:00
|
|
|
static inline unsigned int drm_crtc_index(const struct drm_crtc *crtc)
|
2016-05-27 22:05:00 +03:00
|
|
|
{
|
|
|
|
return crtc->index;
|
|
|
|
}
|
2014-01-03 01:27:33 +04:00
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_crtc_mask - find the mask of a registered CRTC
|
|
|
|
* @crtc: CRTC to find mask for
|
|
|
|
*
|
2018-07-09 11:40:10 +03:00
|
|
|
* Given a registered CRTC, return the mask bit of that CRTC for the
|
|
|
|
* &drm_encoder.possible_crtcs and &drm_plane.possible_crtcs fields.
|
2014-01-03 01:27:33 +04:00
|
|
|
*/
|
2016-10-13 11:38:11 +03:00
|
|
|
static inline uint32_t drm_crtc_mask(const struct drm_crtc *crtc)
|
2014-01-03 01:27:33 +04:00
|
|
|
{
|
|
|
|
return 1 << drm_crtc_index(crtc);
|
|
|
|
}
|
2008-11-08 01:05:41 +03:00
|
|
|
|
2016-11-14 14:58:25 +03:00
|
|
|
int drm_mode_set_config_internal(struct drm_mode_set *set);
|
2016-12-29 15:41:28 +03:00
|
|
|
struct drm_crtc *drm_crtc_from_index(struct drm_device *dev, int idx);
|
2016-06-21 11:54:13 +03:00
|
|
|
|
2017-01-25 09:26:57 +03:00
|
|
|
/**
|
|
|
|
* drm_crtc_find - look up a CRTC object from its ID
|
|
|
|
* @dev: DRM device
|
2017-11-09 02:35:04 +03:00
|
|
|
* @file_priv: drm file to check for lease against.
|
2017-01-25 09:26:57 +03:00
|
|
|
* @id: &drm_mode_object ID
|
|
|
|
*
|
|
|
|
* This can be used to look up a CRTC from its userspace ID. Only used by
|
|
|
|
* drivers for legacy IOCTLs and interface, nowadays extensions to the KMS
|
|
|
|
* userspace interface should be done using &drm_property.
|
|
|
|
*/
|
2012-08-15 16:59:49 +04:00
|
|
|
static inline struct drm_crtc *drm_crtc_find(struct drm_device *dev,
|
2017-03-15 09:25:07 +03:00
|
|
|
struct drm_file *file_priv,
|
|
|
|
uint32_t id)
|
2012-08-15 16:59:49 +04:00
|
|
|
{
|
|
|
|
struct drm_mode_object *mo;
|
2017-03-15 09:25:07 +03:00
|
|
|
mo = drm_mode_object_find(dev, file_priv, id, DRM_MODE_OBJECT_CRTC);
|
2012-08-15 16:59:49 +04:00
|
|
|
return mo ? obj_to_crtc(mo) : NULL;
|
|
|
|
}
|
|
|
|
|
2017-01-25 09:26:57 +03:00
|
|
|
/**
|
|
|
|
* drm_for_each_crtc - iterate over all CRTCs
|
|
|
|
* @crtc: a &struct drm_crtc as the loop cursor
|
|
|
|
* @dev: the &struct drm_device
|
|
|
|
*
|
|
|
|
* Iterate over all CRTCs of @dev.
|
|
|
|
*/
|
drm: Add modeset object iterators
And roll them out across drm_* files. The point here isn't code
prettification (it helps with that too) but that some of these lists
aren't static any more. And having macros will gives us a convenient
place to put locking checks into.
I didn't add an iterator for props since that's only used by a
list_for_each_entry_safe in the driver teardown code.
Search&replace was done with the below cocci spatch. Note that there's
a bunch more places that didn't match and which would need some manual
changes, but I've intentially left these out for this mostly automated
patch.
iterator name drm_for_each_crtc;
struct drm_crtc *crtc;
struct drm_device *dev;
expression head;
@@
- list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
+ drm_for_each_crtc (crtc, dev) {
...
}
@@
iterator name drm_for_each_encoder;
struct drm_encoder *encoder;
struct drm_device *dev;
expression head;
@@
- list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
+ drm_for_each_encoder (encoder, dev) {
...
}
@@
iterator name drm_for_each_fb;
struct drm_framebuffer *fb;
struct drm_device *dev;
expression head;
@@
- list_for_each_entry(fb, &dev->mode_config.fb_list, head) {
+ drm_for_each_fb (fb, dev) {
...
}
@@
iterator name drm_for_each_connector;
struct drm_connector *connector;
struct drm_device *dev;
expression head;
@@
- list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
+ drm_for_each_connector (connector, dev) {
...
}
Reviewed-by: Maarten Lankhorst <maarten.lankhorst@linux.intel.com>
Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>
2015-07-10 00:44:25 +03:00
|
|
|
#define drm_for_each_crtc(crtc, dev) \
|
|
|
|
list_for_each_entry(crtc, &(dev)->mode_config.crtc_list, head)
|
|
|
|
|
2008-11-08 01:05:41 +03:00
|
|
|
#endif /* __DRM_CRTC_H__ */
|