2008-11-07 22:05:41 +00: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/idr.h>
|
|
|
|
#include <linux/fb.h>
|
2013-12-19 10:04:07 +00:00
|
|
|
#include <linux/hdmi.h>
|
2014-07-22 10:09:10 +00:00
|
|
|
#include <linux/media-bus-format.h>
|
2014-08-29 10:12:40 +00:00
|
|
|
#include <uapi/drm/drm_mode.h>
|
|
|
|
#include <uapi/drm/drm_fourcc.h>
|
2013-11-19 17:10:12 +00:00
|
|
|
#include <drm/drm_modeset_lock.h>
|
2016-07-26 16:06:57 +00:00
|
|
|
#include <drm/drm_rect.h>
|
2016-08-29 08:27:51 +00:00
|
|
|
#include <drm/drm_mode_object.h>
|
2016-08-15 14:07:02 +00:00
|
|
|
#include <drm/drm_framebuffer.h>
|
|
|
|
#include <drm/drm_modes.h>
|
2016-08-12 20:48:50 +00:00
|
|
|
#include <drm/drm_connector.h>
|
2016-08-29 08:27:49 +00:00
|
|
|
#include <drm/drm_encoder.h>
|
2016-08-29 08:27:55 +00:00
|
|
|
#include <drm/drm_property.h>
|
2016-08-31 16:09:05 +00:00
|
|
|
#include <drm/drm_bridge.h>
|
2011-11-14 22:51:28 +00:00
|
|
|
|
2008-11-07 22:05:41 +00:00
|
|
|
struct drm_device;
|
|
|
|
struct drm_mode_set;
|
2012-11-21 14:00:47 +00:00
|
|
|
struct drm_file;
|
|
|
|
struct drm_clip_rect;
|
2014-06-15 10:07:12 +00:00
|
|
|
struct device_node;
|
2014-10-29 10:34:56 +00:00
|
|
|
struct fence;
|
2016-06-21 08:54:13 +00:00
|
|
|
struct edid;
|
2008-11-07 22:05:41 +00:00
|
|
|
|
2012-09-13 03:22:31 +00: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);
|
|
|
|
}
|
|
|
|
|
2015-11-02 15:14:08 +00:00
|
|
|
/*
|
|
|
|
* Rotation property bits. DRM_ROTATE_<degrees> rotates the image by the
|
|
|
|
* specified amount in degrees in counter clockwise direction. DRM_REFLECT_X and
|
|
|
|
* DRM_REFLECT_Y reflects the image along the specified axis prior to rotation
|
|
|
|
*/
|
2016-07-29 05:50:05 +00:00
|
|
|
#define DRM_ROTATE_0 BIT(0)
|
|
|
|
#define DRM_ROTATE_90 BIT(1)
|
|
|
|
#define DRM_ROTATE_180 BIT(2)
|
|
|
|
#define DRM_ROTATE_270 BIT(3)
|
|
|
|
#define DRM_ROTATE_MASK (DRM_ROTATE_0 | DRM_ROTATE_90 | \
|
|
|
|
DRM_ROTATE_180 | DRM_ROTATE_270)
|
|
|
|
#define DRM_REFLECT_X BIT(4)
|
|
|
|
#define DRM_REFLECT_Y BIT(5)
|
|
|
|
#define DRM_REFLECT_MASK (DRM_REFLECT_X | DRM_REFLECT_Y)
|
2014-07-08 05:01:51 +00:00
|
|
|
|
2014-10-20 06:17:17 +00:00
|
|
|
/* data corresponds to displayid vend/prod/serial */
|
|
|
|
struct drm_tile_group {
|
|
|
|
struct kref refcount;
|
|
|
|
struct drm_device *dev;
|
|
|
|
int id;
|
|
|
|
u8 group_data[8];
|
|
|
|
};
|
|
|
|
|
2008-11-07 22:05:41 +00:00
|
|
|
struct drm_crtc;
|
|
|
|
struct drm_encoder;
|
2009-11-17 17:43:55 +00:00
|
|
|
struct drm_pending_vblank_event;
|
2011-11-14 22:51:27 +00:00
|
|
|
struct drm_plane;
|
2013-08-14 20:47:37 +00:00
|
|
|
struct drm_bridge;
|
2014-10-27 19:28:44 +00:00
|
|
|
struct drm_atomic_state;
|
|
|
|
|
2015-12-04 08:45:45 +00:00
|
|
|
struct drm_crtc_helper_funcs;
|
|
|
|
struct drm_encoder_helper_funcs;
|
|
|
|
struct drm_plane_helper_funcs;
|
|
|
|
|
2014-10-27 19:28:44 +00:00
|
|
|
/**
|
2014-07-25 19:30:38 +00:00
|
|
|
* struct drm_crtc_state - mutable CRTC state
|
2014-11-27 14:49:39 +00:00
|
|
|
* @crtc: backpointer to the CRTC
|
2014-10-27 19:28:44 +00:00
|
|
|
* @enable: whether the CRTC should be enabled, gates all other state
|
2014-11-26 15:57:41 +00:00
|
|
|
* @active: whether the CRTC is actively displaying (used for DPMS)
|
2015-07-21 11:28:57 +00:00
|
|
|
* @planes_changed: planes on this crtc are updated
|
|
|
|
* @mode_changed: crtc_state->mode or crtc_state->enable has been changed
|
|
|
|
* @active_changed: crtc_state->active has been toggled.
|
|
|
|
* @connectors_changed: connectors to this crtc have been updated
|
2016-06-13 09:11:26 +00:00
|
|
|
* @zpos_changed: zpos values of planes on this crtc have been updated
|
2016-02-26 17:05:00 +00:00
|
|
|
* @color_mgmt_changed: color management properties have changed (degamma or
|
|
|
|
* gamma LUT or CSC matrix)
|
2014-11-21 20:28:31 +00:00
|
|
|
* @plane_mask: bitmask of (1 << drm_plane_index(plane)) of attached planes
|
2016-01-04 11:53:18 +00:00
|
|
|
* @connector_mask: bitmask of (1 << drm_connector_index(connector)) of attached connectors
|
2016-01-28 14:04:58 +00:00
|
|
|
* @encoder_mask: bitmask of (1 << drm_encoder_index(encoder)) of attached encoders
|
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 15:50:47 +00:00
|
|
|
* @last_vblank_count: for helpers and drivers to capture the vblank of the
|
|
|
|
* update to ensure framebuffer cleanup isn't done too early
|
2014-10-29 10:13:47 +00:00
|
|
|
* @adjusted_mode: for use by helpers and drivers to compute adjusted mode timings
|
2014-10-27 19:28:44 +00:00
|
|
|
* @mode: current mode timings
|
2016-05-31 21:11:10 +00:00
|
|
|
* @mode_blob: &drm_property_blob for @mode
|
2016-02-26 17:05:00 +00:00
|
|
|
* @degamma_lut: Lookup table for converting framebuffer pixel data
|
|
|
|
* before apply the conversion matrix
|
|
|
|
* @ctm: Transformation matrix
|
|
|
|
* @gamma_lut: Lookup table for converting pixel data after the
|
|
|
|
* conversion matrix
|
2014-10-27 19:28:44 +00:00
|
|
|
* @event: optional pointer to a DRM event to signal upon completion of the
|
|
|
|
* state update
|
|
|
|
* @state: backpointer to global drm_atomic_state
|
2014-11-26 15:57:41 +00:00
|
|
|
*
|
|
|
|
* Note that the distinction between @enable and @active is rather subtile:
|
|
|
|
* Flipping @active while @enable is set without changing anything else may
|
|
|
|
* never return in a failure from the ->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.
|
2014-10-27 19:28:44 +00:00
|
|
|
*/
|
|
|
|
struct drm_crtc_state {
|
2014-11-27 14:49:39 +00:00
|
|
|
struct drm_crtc *crtc;
|
|
|
|
|
2014-07-25 19:30:38 +00:00
|
|
|
bool enable;
|
2014-11-26 15:57:41 +00:00
|
|
|
bool active;
|
2014-10-27 19:28:44 +00:00
|
|
|
|
2014-11-04 23:14:14 +00:00
|
|
|
/* computed state bits used by helpers and drivers */
|
|
|
|
bool planes_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 15:50:47 +00:00
|
|
|
bool mode_changed : 1;
|
2015-01-22 15:36:21 +00:00
|
|
|
bool active_changed : 1;
|
2015-07-21 11:28:57 +00:00
|
|
|
bool connectors_changed : 1;
|
2016-06-13 09:11:26 +00:00
|
|
|
bool zpos_changed : 1;
|
2016-02-26 17:05:00 +00: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 15:50:47 +00:00
|
|
|
|
2014-11-21 20:28:31 +00:00
|
|
|
/* attached planes bitmask:
|
|
|
|
* WARNING: transitional helpers do not maintain plane_mask so
|
|
|
|
* drivers not converted over to atomic helpers should not rely
|
|
|
|
* on plane_mask being accurate!
|
|
|
|
*/
|
|
|
|
u32 plane_mask;
|
|
|
|
|
2016-01-04 11:53:18 +00:00
|
|
|
u32 connector_mask;
|
2016-01-28 14:04:58 +00:00
|
|
|
u32 encoder_mask;
|
2016-01-04 11:53:18 +00:00
|
|
|
|
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 15:50:47 +00:00
|
|
|
/* last_vblank_count: for vblank waits before cleanup */
|
|
|
|
u32 last_vblank_count;
|
2014-11-04 23:14:14 +00:00
|
|
|
|
2014-10-29 10:13:47 +00:00
|
|
|
/* adjusted_mode: for use by helpers and drivers */
|
|
|
|
struct drm_display_mode adjusted_mode;
|
|
|
|
|
2014-10-27 19:28:44 +00:00
|
|
|
struct drm_display_mode mode;
|
|
|
|
|
2015-05-25 18:11:51 +00:00
|
|
|
/* blob property to expose current mode to atomic userspace */
|
|
|
|
struct drm_property_blob *mode_blob;
|
|
|
|
|
2016-02-26 17:05:00 +00:00
|
|
|
/* blob property to expose color management to userspace */
|
|
|
|
struct drm_property_blob *degamma_lut;
|
|
|
|
struct drm_property_blob *ctm;
|
|
|
|
struct drm_property_blob *gamma_lut;
|
|
|
|
|
2014-10-27 19:28:44 +00:00
|
|
|
struct drm_pending_vblank_event *event;
|
|
|
|
|
|
|
|
struct drm_atomic_state *state;
|
|
|
|
};
|
2008-11-07 22:05:41 +00:00
|
|
|
|
|
|
|
/**
|
2014-10-27 15:54:27 +00:00
|
|
|
* struct drm_crtc_funcs - control CRTCs for a given device
|
2008-11-07 22:05:41 +00: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 08:45:48 +00: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 15:11:08 +00:00
|
|
|
void (*reset)(struct drm_crtc *crtc);
|
2008-11-07 22:05:41 +00:00
|
|
|
|
2015-12-04 08:46:00 +00: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-07 22:05:41 +00: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 08:46:00 +00: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 01:48:52 +00: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 08:46:00 +00: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-07 22:05:41 +00:00
|
|
|
int (*cursor_move)(struct drm_crtc *crtc, int x, int y);
|
|
|
|
|
2015-12-04 08:46:00 +00:00
|
|
|
/**
|
|
|
|
* @gamma_set:
|
|
|
|
*
|
|
|
|
* Set gamma on the CRTC.
|
|
|
|
*
|
|
|
|
* This callback is optional.
|
|
|
|
*
|
|
|
|
* NOTE:
|
|
|
|
*
|
|
|
|
* Drivers that support gamma tables and also fbdev emulation through
|
|
|
|
* the provided helper library need to take care to fill out the gamma
|
|
|
|
* hooks for both. Currently there's a bit an unfortunate duplication
|
|
|
|
* going on, which should eventually be unified to just one set of
|
|
|
|
* hooks.
|
|
|
|
*/
|
2016-06-07 10:49:30 +00:00
|
|
|
int (*gamma_set)(struct drm_crtc *crtc, u16 *r, u16 *g, u16 *b,
|
|
|
|
uint32_t size);
|
2015-12-04 08:45:48 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @destroy:
|
|
|
|
*
|
|
|
|
* Clean up plane resources. This is only called at driver unload time
|
|
|
|
* through drm_mode_config_cleanup() since a CRTC cannot be hotplugged
|
|
|
|
* in DRM.
|
|
|
|
*/
|
2008-11-07 22:05:41 +00:00
|
|
|
void (*destroy)(struct drm_crtc *crtc);
|
|
|
|
|
2015-12-04 08:46:00 +00: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
|
|
|
|
* struct &drm_mode_set - see there for details.
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*/
|
2008-11-07 22:05:41 +00:00
|
|
|
int (*set_config)(struct drm_mode_set *set);
|
2009-11-17 17:43:55 +00:00
|
|
|
|
2015-12-04 08:46:00 +00: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
|
|
|
|
* configured mode and then calls the CRTC ->page_flip() operation with a
|
|
|
|
* pointer to the new frame buffer.
|
|
|
|
*
|
|
|
|
* 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
|
|
|
|
* completed. The drm core will supply a struct &drm_event in the event
|
|
|
|
* 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
|
|
|
|
* ->page_flip() operation is already pending the callback should return
|
|
|
|
* -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 08:49:20 +00: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 17:43:55 +00:00
|
|
|
*/
|
|
|
|
int (*page_flip)(struct drm_crtc *crtc,
|
|
|
|
struct drm_framebuffer *fb,
|
2013-07-23 01:49:58 +00:00
|
|
|
struct drm_pending_vblank_event *event,
|
|
|
|
uint32_t flags);
|
2012-05-15 21:09:05 +00:00
|
|
|
|
2016-08-08 07:23:03 +00: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,
|
|
|
|
uint32_t flags, uint32_t target);
|
|
|
|
|
2015-12-04 08:45:48 +00:00
|
|
|
/**
|
|
|
|
* @set_property:
|
|
|
|
*
|
|
|
|
* This is the legacy entry point to update a property attached to the
|
|
|
|
* CRTC.
|
|
|
|
*
|
|
|
|
* Drivers implementing atomic modeset should use
|
|
|
|
* drm_atomic_helper_crtc_set_property() to implement this hook.
|
|
|
|
*
|
|
|
|
* This callback is optional if the driver does not support any legacy
|
|
|
|
* driver-private properties.
|
|
|
|
*
|
|
|
|
* RETURNS:
|
|
|
|
*
|
|
|
|
* 0 on success or a negative error code on failure.
|
|
|
|
*/
|
2012-05-15 21:09:05 +00:00
|
|
|
int (*set_property)(struct drm_crtc *crtc,
|
|
|
|
struct drm_property *property, uint64_t val);
|
2014-10-27 19:28:44 +00:00
|
|
|
|
2015-12-04 08:45:48 +00:00
|
|
|
/**
|
|
|
|
* @atomic_duplicate_state:
|
|
|
|
*
|
|
|
|
* Duplicate the current atomic state for this CRTC and return it.
|
|
|
|
* The core and helpers gurantee that any atomic state duplicated with
|
|
|
|
* this hook and still owned by the caller (i.e. not transferred to the
|
|
|
|
* driver by calling ->atomic_commit() from struct
|
|
|
|
* &drm_mode_config_funcs) will be cleaned up by calling the
|
|
|
|
* @atomic_destroy_state hook in this structure.
|
|
|
|
*
|
|
|
|
* Atomic drivers which don't subclass struct &drm_crtc should use
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
* It is an error to call this hook before crtc->state has been
|
|
|
|
* 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 19:28:44 +00:00
|
|
|
struct drm_crtc_state *(*atomic_duplicate_state)(struct drm_crtc *crtc);
|
2015-12-04 08:45:48 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @atomic_destroy_state:
|
|
|
|
*
|
|
|
|
* Destroy a state duplicated with @atomic_duplicate_state and release
|
|
|
|
* or unreference all resources it references
|
|
|
|
*/
|
2014-10-27 19:28:44 +00:00
|
|
|
void (*atomic_destroy_state)(struct drm_crtc *crtc,
|
2014-07-25 19:30:38 +00:00
|
|
|
struct drm_crtc_state *state);
|
2015-12-04 08:45:48 +00: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 19:28:44 +00:00
|
|
|
int (*atomic_set_property)(struct drm_crtc *crtc,
|
|
|
|
struct drm_crtc_state *state,
|
|
|
|
struct drm_property *property,
|
|
|
|
uint64_t val);
|
2015-12-04 08:45:48 +00:00
|
|
|
/**
|
|
|
|
* @atomic_get_property:
|
|
|
|
*
|
|
|
|
* Reads out the decoded driver-private property. This is used to
|
2015-12-04 08:46:01 +00:00
|
|
|
* implement the GETCRTC IOCTL.
|
2015-12-04 08:45:48 +00: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-18 21:01:47 +00: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 14:37:09 +00: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
|
|
|
|
* late_unregister(). It is called from drm_dev_unregister(),
|
|
|
|
* early in the driver unload sequence to disable userspace access
|
|
|
|
* before data structures are torndown.
|
|
|
|
*/
|
|
|
|
void (*early_unregister)(struct drm_crtc *crtc);
|
2008-11-07 22:05:41 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
2014-10-27 15:54:27 +00:00
|
|
|
* struct drm_crtc - central CRTC control structure
|
2011-11-07 20:03:14 +00:00
|
|
|
* @dev: parent DRM device
|
2014-10-27 19:19:38 +00:00
|
|
|
* @port: OF node used by drm_of_find_possible_crtcs()
|
2011-11-07 20:03:14 +00:00
|
|
|
* @head: list management
|
2016-05-31 21:11:10 +00:00
|
|
|
* @name: human readable name, can be overwritten by the driver
|
2013-11-19 17:10:12 +00:00
|
|
|
* @mutex: per-CRTC locking
|
2011-11-07 20:03:14 +00:00
|
|
|
* @base: base KMS object for ID tracking etc.
|
2014-04-01 22:22:38 +00:00
|
|
|
* @primary: primary plane for this CRTC
|
|
|
|
* @cursor: cursor plane for this CRTC
|
2014-10-27 19:19:38 +00:00
|
|
|
* @cursor_x: current x position of the cursor, used for universal cursor planes
|
|
|
|
* @cursor_y: current y position of the cursor, used for universal cursor planes
|
2008-11-07 22:05:41 +00:00
|
|
|
* @enabled: is this CRTC enabled?
|
2011-11-07 20:03:14 +00:00
|
|
|
* @mode: current mode timings
|
|
|
|
* @hwmode: mode timings as programmed to hw regs
|
2008-11-07 22:05:41 +00:00
|
|
|
* @x: x position on screen
|
|
|
|
* @y: y position on screen
|
|
|
|
* @funcs: CRTC control functions
|
2011-11-07 20:03:14 +00:00
|
|
|
* @gamma_size: size of gamma ramp
|
|
|
|
* @gamma_store: gamma ramp values
|
|
|
|
* @helper_private: mid-layer private data
|
2012-05-15 21:09:05 +00:00
|
|
|
* @properties: property tracking for this CRTC
|
2008-11-07 22:05:41 +00:00
|
|
|
*
|
|
|
|
* Each CRTC may have one or more connectors associated with it. This structure
|
|
|
|
* allows the CRTC to be controlled.
|
|
|
|
*/
|
|
|
|
struct drm_crtc {
|
|
|
|
struct drm_device *dev;
|
2014-06-15 10:07:12 +00:00
|
|
|
struct device_node *port;
|
2008-11-07 22:05:41 +00:00
|
|
|
struct list_head head;
|
|
|
|
|
2015-12-08 16:41:53 +00:00
|
|
|
char *name;
|
|
|
|
|
2016-05-31 21:11:10 +00: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 01:18:25 +00:00
|
|
|
*
|
|
|
|
* This provides a read lock for the overall crtc state (mode, dpms
|
|
|
|
* state, ...) and a write lock for everything which can be update
|
2016-05-31 21:11:10 +00:00
|
|
|
* without a full modeset (fb, cursor data, crtc properties ...). Full
|
|
|
|
* modeset also need to grab dev->mode_config.connection_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 01:18:25 +00:00
|
|
|
*/
|
2013-11-19 17:10:12 +00: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 01:18:25 +00:00
|
|
|
|
2008-11-07 22:05:41 +00:00
|
|
|
struct drm_mode_object base;
|
|
|
|
|
2014-04-01 22:22:38 +00:00
|
|
|
/* primary and cursor planes for CRTC */
|
|
|
|
struct drm_plane *primary;
|
|
|
|
struct drm_plane *cursor;
|
|
|
|
|
2016-07-15 19:47:59 +00: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 19:05:00 +00:00
|
|
|
unsigned index;
|
|
|
|
|
2014-06-10 15:28:10 +00:00
|
|
|
/* position of cursor plane on crtc */
|
|
|
|
int cursor_x;
|
|
|
|
int cursor_y;
|
|
|
|
|
2008-11-07 22:05:41 +00:00
|
|
|
bool enabled;
|
|
|
|
|
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 02:20:23 +00:00
|
|
|
/* Requested mode from modesetting. */
|
2008-11-07 22:05:41 +00:00
|
|
|
struct drm_display_mode mode;
|
|
|
|
|
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 02:20:23 +00:00
|
|
|
/* Programmed mode in hw, after adjustments for encoders,
|
|
|
|
* crtc, panel scaling etc. Needed for timestamping etc.
|
|
|
|
*/
|
|
|
|
struct drm_display_mode hwmode;
|
|
|
|
|
2008-11-07 22:05:41 +00:00
|
|
|
int x, y;
|
|
|
|
const struct drm_crtc_funcs *funcs;
|
|
|
|
|
2016-02-26 17:05:00 +00:00
|
|
|
/* Legacy FB CRTC gamma size for reporting to userspace */
|
2008-11-07 22:05:41 +00:00
|
|
|
uint32_t gamma_size;
|
|
|
|
uint16_t *gamma_store;
|
|
|
|
|
|
|
|
/* if you are using the helper */
|
2015-12-04 08:45:45 +00:00
|
|
|
const struct drm_crtc_helper_funcs *helper_private;
|
2012-05-15 21:09:05 +00:00
|
|
|
|
|
|
|
struct drm_object_properties properties;
|
2014-07-25 16:07:40 +00:00
|
|
|
|
2016-06-08 12:19:00 +00:00
|
|
|
/**
|
|
|
|
* @state:
|
|
|
|
*
|
|
|
|
* Current atomic state for this CRTC.
|
|
|
|
*/
|
2014-10-27 19:28:44 +00:00
|
|
|
struct drm_crtc_state *state;
|
|
|
|
|
2016-06-08 12:19:00 +00:00
|
|
|
/**
|
|
|
|
* @commit_list:
|
|
|
|
*
|
|
|
|
* List of &drm_crtc_commit structures tracking pending commits.
|
|
|
|
* Protected by @commit_lock. This list doesn't hold its own full
|
|
|
|
* reference, but burrows it from the ongoing commit. Commit entries
|
|
|
|
* must be removed from this list once the commit is fully completed,
|
|
|
|
* but before it's correspoding &drm_atomic_state gets destroyed.
|
|
|
|
*/
|
|
|
|
struct list_head commit_list;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @commit_lock:
|
|
|
|
*
|
|
|
|
* Spinlock to protect @commit_list.
|
|
|
|
*/
|
|
|
|
spinlock_t commit_lock;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @acquire_ctx:
|
|
|
|
*
|
|
|
|
* Per-CRTC implicit acquire context used by atomic drivers for legacy
|
|
|
|
* IOCTLs, so that atomic drivers can get at the locking acquire
|
|
|
|
* context.
|
2014-07-25 16:07:40 +00:00
|
|
|
*/
|
|
|
|
struct drm_modeset_acquire_ctx *acquire_ctx;
|
2008-11-07 22:05:41 +00:00
|
|
|
};
|
|
|
|
|
2014-10-27 19:28:44 +00:00
|
|
|
/**
|
|
|
|
* struct drm_plane_state - mutable plane state
|
2014-11-27 14:49:39 +00:00
|
|
|
* @plane: backpointer to the plane
|
2014-10-27 19:28:44 +00:00
|
|
|
* @crtc: currently bound CRTC, NULL if disabled
|
2014-07-25 19:30:38 +00:00
|
|
|
* @fb: currently bound framebuffer
|
2014-10-29 10:34:56 +00:00
|
|
|
* @fence: optional fence to wait for before scanning out @fb
|
2014-10-27 19:28:44 +00:00
|
|
|
* @crtc_x: left position of visible portion of plane on crtc
|
|
|
|
* @crtc_y: upper position of visible portion of plane on crtc
|
|
|
|
* @crtc_w: width of visible portion of plane on crtc
|
|
|
|
* @crtc_h: height of visible portion of plane on crtc
|
|
|
|
* @src_x: left position of visible portion of plane within
|
|
|
|
* plane (in 16.16)
|
|
|
|
* @src_y: upper position of visible portion of plane within
|
|
|
|
* plane (in 16.16)
|
|
|
|
* @src_w: width of visible portion of plane (in 16.16)
|
|
|
|
* @src_h: height of visible portion of plane (in 16.16)
|
2016-05-31 21:11:10 +00:00
|
|
|
* @rotation: rotation of the plane
|
2016-06-13 09:11:26 +00:00
|
|
|
* @zpos: priority of the given plane on crtc (optional)
|
|
|
|
* @normalized_zpos: normalized value of zpos: unique, range from 0 to N-1
|
|
|
|
* where N is the number of active planes for given crtc
|
2016-07-26 16:06:57 +00:00
|
|
|
* @src: clipped source coordinates of the plane (in 16.16)
|
|
|
|
* @dst: clipped destination coordinates of the plane
|
|
|
|
* @visible: visibility of the plane
|
2014-10-27 19:28:44 +00:00
|
|
|
* @state: backpointer to global drm_atomic_state
|
|
|
|
*/
|
|
|
|
struct drm_plane_state {
|
2014-11-27 14:49:39 +00:00
|
|
|
struct drm_plane *plane;
|
|
|
|
|
2014-11-21 20:28:31 +00:00
|
|
|
struct drm_crtc *crtc; /* do not write directly, use drm_atomic_set_crtc_for_plane() */
|
|
|
|
struct drm_framebuffer *fb; /* do not write directly, use drm_atomic_set_fb_for_plane() */
|
2014-10-29 10:34:56 +00:00
|
|
|
struct fence *fence;
|
2014-10-27 19:28:44 +00:00
|
|
|
|
|
|
|
/* Signed dest location allows it to be partially off screen */
|
|
|
|
int32_t crtc_x, crtc_y;
|
|
|
|
uint32_t crtc_w, crtc_h;
|
|
|
|
|
|
|
|
/* Source values are 16.16 fixed point */
|
|
|
|
uint32_t src_x, src_y;
|
|
|
|
uint32_t src_h, src_w;
|
|
|
|
|
2015-01-22 00:35:40 +00:00
|
|
|
/* Plane rotation */
|
|
|
|
unsigned int rotation;
|
|
|
|
|
2016-06-13 09:11:26 +00:00
|
|
|
/* Plane zpos */
|
|
|
|
unsigned int zpos;
|
|
|
|
unsigned int normalized_zpos;
|
|
|
|
|
2016-07-26 16:06:57 +00:00
|
|
|
/* Clipped coordinates */
|
|
|
|
struct drm_rect src, dst;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Is the plane actually visible? Can be false even
|
|
|
|
* if fb!=NULL and crtc!=NULL, due to clipping.
|
|
|
|
*/
|
|
|
|
bool visible;
|
|
|
|
|
2014-10-27 19:28:44 +00:00
|
|
|
struct drm_atomic_state *state;
|
2008-11-07 22:05:41 +00:00
|
|
|
};
|
|
|
|
|
2014-10-27 19:28:44 +00:00
|
|
|
|
2011-11-14 22:51:27 +00:00
|
|
|
/**
|
2014-10-27 15:54:27 +00:00
|
|
|
* struct drm_plane_funcs - driver plane control functions
|
2011-11-14 22:51:27 +00:00
|
|
|
*/
|
|
|
|
struct drm_plane_funcs {
|
2015-12-04 08:45:48 +00:00
|
|
|
/**
|
|
|
|
* @update_plane:
|
|
|
|
*
|
|
|
|
* This is the legacy entry point to enable and configure the plane for
|
|
|
|
* the given CRTC and framebuffer. It is never called to disable the
|
|
|
|
* plane, i.e. the passed-in crtc and fb paramters are never NULL.
|
|
|
|
*
|
|
|
|
* The source rectangle in frame buffer memory coordinates is given by
|
|
|
|
* the src_x, src_y, src_w and src_h parameters (as 16.16 fixed point
|
|
|
|
* values). Devices that don't support subpixel plane coordinates can
|
|
|
|
* ignore the fractional part.
|
|
|
|
*
|
|
|
|
* The destination rectangle in CRTC coordinates is given by the
|
|
|
|
* crtc_x, crtc_y, crtc_w and crtc_h parameters (as integer values).
|
|
|
|
* Devices scale the source rectangle to the destination rectangle. If
|
|
|
|
* scaling is not supported, and the source rectangle size doesn't match
|
|
|
|
* the destination rectangle size, the driver must return a
|
|
|
|
* -<errorname>EINVAL</errorname> error.
|
|
|
|
*
|
|
|
|
* Drivers implementing atomic modeset should use
|
|
|
|
* drm_atomic_helper_update_plane() to implement this hook.
|
|
|
|
*
|
|
|
|
* RETURNS:
|
|
|
|
*
|
|
|
|
* 0 on success or a negative error code on failure.
|
|
|
|
*/
|
2011-11-14 22:51:27 +00:00
|
|
|
int (*update_plane)(struct drm_plane *plane,
|
|
|
|
struct drm_crtc *crtc, struct drm_framebuffer *fb,
|
|
|
|
int crtc_x, int crtc_y,
|
|
|
|
unsigned int crtc_w, unsigned int crtc_h,
|
|
|
|
uint32_t src_x, uint32_t src_y,
|
|
|
|
uint32_t src_w, uint32_t src_h);
|
2015-12-04 08:45:48 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @disable_plane:
|
|
|
|
*
|
|
|
|
* This is the legacy entry point to disable the plane. The DRM core
|
2015-12-04 08:46:01 +00:00
|
|
|
* calls this method in response to a DRM_IOCTL_MODE_SETPLANE IOCTL call
|
2015-12-04 08:45:48 +00:00
|
|
|
* with the frame buffer ID set to 0. Disabled planes must not be
|
|
|
|
* processed by the CRTC.
|
|
|
|
*
|
|
|
|
* Drivers implementing atomic modeset should use
|
|
|
|
* drm_atomic_helper_disable_plane() to implement this hook.
|
|
|
|
*
|
|
|
|
* RETURNS:
|
|
|
|
*
|
|
|
|
* 0 on success or a negative error code on failure.
|
|
|
|
*/
|
2011-11-14 22:51:27 +00:00
|
|
|
int (*disable_plane)(struct drm_plane *plane);
|
2015-12-04 08:45:48 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @destroy:
|
|
|
|
*
|
|
|
|
* Clean up plane resources. This is only called at driver unload time
|
|
|
|
* through drm_mode_config_cleanup() since a plane cannot be hotplugged
|
|
|
|
* in DRM.
|
|
|
|
*/
|
2011-11-14 22:51:27 +00:00
|
|
|
void (*destroy)(struct drm_plane *plane);
|
2015-12-04 08:45:48 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @reset:
|
|
|
|
*
|
|
|
|
* Reset plane 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_plane_reset() to reset
|
|
|
|
* atomic state using this hook.
|
|
|
|
*/
|
2014-07-29 13:32:37 +00:00
|
|
|
void (*reset)(struct drm_plane *plane);
|
2012-05-17 08:23:27 +00:00
|
|
|
|
2015-12-04 08:45:48 +00:00
|
|
|
/**
|
|
|
|
* @set_property:
|
|
|
|
*
|
|
|
|
* This is the legacy entry point to update a property attached to the
|
|
|
|
* plane.
|
|
|
|
*
|
|
|
|
* Drivers implementing atomic modeset should use
|
|
|
|
* drm_atomic_helper_plane_set_property() to implement this hook.
|
|
|
|
*
|
|
|
|
* This callback is optional if the driver does not support any legacy
|
|
|
|
* driver-private properties.
|
|
|
|
*
|
|
|
|
* RETURNS:
|
|
|
|
*
|
|
|
|
* 0 on success or a negative error code on failure.
|
|
|
|
*/
|
2012-05-17 08:23:27 +00:00
|
|
|
int (*set_property)(struct drm_plane *plane,
|
|
|
|
struct drm_property *property, uint64_t val);
|
2014-10-27 19:28:44 +00:00
|
|
|
|
2015-12-04 08:45:48 +00:00
|
|
|
/**
|
|
|
|
* @atomic_duplicate_state:
|
|
|
|
*
|
|
|
|
* Duplicate the current atomic state for this plane and return it.
|
|
|
|
* The core and helpers gurantee that any atomic state duplicated with
|
|
|
|
* this hook and still owned by the caller (i.e. not transferred to the
|
|
|
|
* driver by calling ->atomic_commit() from struct
|
|
|
|
* &drm_mode_config_funcs) will be cleaned up by calling the
|
|
|
|
* @atomic_destroy_state hook in this structure.
|
|
|
|
*
|
|
|
|
* Atomic drivers which don't subclass struct &drm_plane_state should use
|
|
|
|
* drm_atomic_helper_plane_duplicate_state(). Drivers that subclass the
|
|
|
|
* state structure to extend it with driver-private state should use
|
|
|
|
* __drm_atomic_helper_plane_duplicate_state() to make sure shared state is
|
|
|
|
* duplicated in a consistent fashion across drivers.
|
|
|
|
*
|
|
|
|
* It is an error to call this hook before plane->state has been
|
|
|
|
* 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 19:28:44 +00:00
|
|
|
struct drm_plane_state *(*atomic_duplicate_state)(struct drm_plane *plane);
|
2015-12-04 08:45:48 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @atomic_destroy_state:
|
|
|
|
*
|
|
|
|
* Destroy a state duplicated with @atomic_duplicate_state and release
|
|
|
|
* or unreference all resources it references
|
|
|
|
*/
|
2014-10-27 19:28:44 +00:00
|
|
|
void (*atomic_destroy_state)(struct drm_plane *plane,
|
2014-07-25 19:30:38 +00:00
|
|
|
struct drm_plane_state *state);
|
2015-12-04 08:45:48 +00: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_plane_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 shouldn't ever happen, the core only
|
|
|
|
* asks for properties attached to this plane). 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 19:28:44 +00:00
|
|
|
int (*atomic_set_property)(struct drm_plane *plane,
|
|
|
|
struct drm_plane_state *state,
|
|
|
|
struct drm_property *property,
|
|
|
|
uint64_t val);
|
2015-12-04 08:45:48 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @atomic_get_property:
|
|
|
|
*
|
|
|
|
* Reads out the decoded driver-private property. This is used to
|
2015-12-04 08:46:01 +00:00
|
|
|
* implement the GETPLANE IOCTL.
|
2015-12-04 08:45:48 +00:00
|
|
|
*
|
|
|
|
* Do not call this function directly, use
|
|
|
|
* drm_atomic_plane_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 plane).
|
|
|
|
*/
|
2014-12-18 21:01:47 +00:00
|
|
|
int (*atomic_get_property)(struct drm_plane *plane,
|
|
|
|
const struct drm_plane_state *state,
|
|
|
|
struct drm_property *property,
|
|
|
|
uint64_t *val);
|
2016-06-21 14:37:09 +00:00
|
|
|
/**
|
|
|
|
* @late_register:
|
|
|
|
*
|
|
|
|
* This optional hook can be used to register additional userspace
|
|
|
|
* interfaces attached to the plane 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_plane *plane);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @early_unregister:
|
|
|
|
*
|
|
|
|
* This optional hook should be used to unregister the additional
|
|
|
|
* userspace interfaces attached to the plane from
|
|
|
|
* late_unregister(). It is called from drm_dev_unregister(),
|
|
|
|
* early in the driver unload sequence to disable userspace access
|
|
|
|
* before data structures are torndown.
|
|
|
|
*/
|
|
|
|
void (*early_unregister)(struct drm_plane *plane);
|
2011-11-14 22:51:27 +00:00
|
|
|
};
|
|
|
|
|
2014-04-01 22:22:30 +00:00
|
|
|
enum drm_plane_type {
|
|
|
|
DRM_PLANE_TYPE_OVERLAY,
|
|
|
|
DRM_PLANE_TYPE_PRIMARY,
|
|
|
|
DRM_PLANE_TYPE_CURSOR,
|
|
|
|
};
|
|
|
|
|
2015-12-04 08:45:48 +00:00
|
|
|
|
2011-11-14 22:51:27 +00:00
|
|
|
/**
|
2014-10-27 15:54:27 +00:00
|
|
|
* struct drm_plane - central DRM plane control structure
|
2011-11-14 22:51:27 +00:00
|
|
|
* @dev: DRM device this plane belongs to
|
|
|
|
* @head: for list management
|
2016-05-31 21:11:10 +00:00
|
|
|
* @name: human readable name, can be overwritten by the driver
|
2011-11-14 22:51:27 +00:00
|
|
|
* @base: base mode object
|
|
|
|
* @possible_crtcs: pipes this plane can be bound to
|
|
|
|
* @format_types: array of formats supported by this plane
|
|
|
|
* @format_count: number of formats supported
|
2015-03-09 08:41:07 +00:00
|
|
|
* @format_default: driver hasn't supplied supported formats for the plane
|
2011-11-14 22:51:27 +00:00
|
|
|
* @crtc: currently bound CRTC
|
|
|
|
* @fb: currently bound fb
|
2014-10-27 19:19:38 +00:00
|
|
|
* @old_fb: Temporary tracking of the old fb while a modeset is ongoing. Used by
|
|
|
|
* drm_mode_set_config_internal() to implement correct refcounting.
|
2011-11-14 22:51:27 +00:00
|
|
|
* @funcs: helper functions
|
2012-05-17 08:23:27 +00:00
|
|
|
* @properties: property tracking for this plane
|
2014-04-01 22:22:30 +00:00
|
|
|
* @type: type of plane (overlay, primary, cursor)
|
2014-10-27 19:28:44 +00:00
|
|
|
* @state: current atomic state for this plane
|
2016-06-13 09:11:26 +00:00
|
|
|
* @zpos_property: zpos property for this plane
|
2016-05-31 21:11:10 +00:00
|
|
|
* @helper_private: mid-layer private data
|
2011-11-14 22:51:27 +00:00
|
|
|
*/
|
|
|
|
struct drm_plane {
|
|
|
|
struct drm_device *dev;
|
|
|
|
struct list_head head;
|
|
|
|
|
2015-12-08 16:41:54 +00:00
|
|
|
char *name;
|
|
|
|
|
2016-05-31 21:11:10 +00:00
|
|
|
/**
|
|
|
|
* @mutex:
|
|
|
|
*
|
|
|
|
* Protects modeset plane state, together with the mutex of &drm_crtc
|
|
|
|
* this plane is linked to (when active, getting actived or getting
|
|
|
|
* disabled).
|
|
|
|
*/
|
2014-11-11 09:12:00 +00:00
|
|
|
struct drm_modeset_lock mutex;
|
|
|
|
|
2011-11-14 22:51:27 +00:00
|
|
|
struct drm_mode_object base;
|
|
|
|
|
|
|
|
uint32_t possible_crtcs;
|
|
|
|
uint32_t *format_types;
|
2015-08-12 14:54:28 +00:00
|
|
|
unsigned int format_count;
|
2015-03-09 08:41:07 +00:00
|
|
|
bool format_default;
|
2011-11-14 22:51:27 +00:00
|
|
|
|
|
|
|
struct drm_crtc *crtc;
|
|
|
|
struct drm_framebuffer *fb;
|
|
|
|
|
2014-07-27 11:42:42 +00:00
|
|
|
struct drm_framebuffer *old_fb;
|
|
|
|
|
2011-11-14 22:51:27 +00:00
|
|
|
const struct drm_plane_funcs *funcs;
|
2012-05-17 08:23:27 +00:00
|
|
|
|
|
|
|
struct drm_object_properties properties;
|
2014-04-01 22:22:30 +00:00
|
|
|
|
|
|
|
enum drm_plane_type type;
|
2014-10-27 19:28:44 +00:00
|
|
|
|
2016-07-15 19:47:59 +00:00
|
|
|
/**
|
|
|
|
* @index: Position inside the mode_config.list, can be used as an array
|
|
|
|
* index. It is invariant over the lifetime of the plane.
|
|
|
|
*/
|
2016-05-27 19:05:00 +00:00
|
|
|
unsigned index;
|
|
|
|
|
2015-12-04 08:45:45 +00:00
|
|
|
const struct drm_plane_helper_funcs *helper_private;
|
2014-11-04 23:14:14 +00:00
|
|
|
|
2014-10-27 19:28:44 +00:00
|
|
|
struct drm_plane_state *state;
|
2016-06-13 09:11:26 +00:00
|
|
|
|
|
|
|
struct drm_property *zpos_property;
|
2011-11-14 22:51:27 +00:00
|
|
|
};
|
|
|
|
|
2016-06-08 12:19:00 +00:00
|
|
|
/**
|
|
|
|
* struct drm_crtc_commit - track modeset commits on a CRTC
|
|
|
|
*
|
|
|
|
* This structure is used to track pending modeset changes and atomic commit on
|
|
|
|
* a per-CRTC basis. Since updating the list should never block this structure
|
|
|
|
* is reference counted to allow waiters to safely wait on an event to complete,
|
|
|
|
* without holding any locks.
|
|
|
|
*
|
|
|
|
* It has 3 different events in total to allow a fine-grained synchronization
|
|
|
|
* between outstanding updates::
|
|
|
|
*
|
|
|
|
* atomic commit thread hardware
|
|
|
|
*
|
|
|
|
* write new state into hardware ----> ...
|
|
|
|
* signal hw_done
|
|
|
|
* switch to new state on next
|
|
|
|
* ... v/hblank
|
|
|
|
*
|
|
|
|
* wait for buffers to show up ...
|
|
|
|
*
|
|
|
|
* ... send completion irq
|
|
|
|
* irq handler signals flip_done
|
|
|
|
* cleanup old buffers
|
|
|
|
*
|
|
|
|
* signal cleanup_done
|
|
|
|
*
|
|
|
|
* wait for flip_done <----
|
|
|
|
* clean up atomic state
|
|
|
|
*
|
|
|
|
* The important bit to know is that cleanup_done is the terminal event, but the
|
|
|
|
* ordering between flip_done and hw_done is entirely up to the specific driver
|
|
|
|
* and modeset state change.
|
|
|
|
*
|
|
|
|
* For an implementation of how to use this look at
|
|
|
|
* drm_atomic_helper_setup_commit() from the atomic helper library.
|
|
|
|
*/
|
|
|
|
struct drm_crtc_commit {
|
|
|
|
/**
|
|
|
|
* @crtc:
|
|
|
|
*
|
|
|
|
* DRM CRTC for this commit.
|
|
|
|
*/
|
|
|
|
struct drm_crtc *crtc;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @ref:
|
|
|
|
*
|
|
|
|
* Reference count for this structure. Needed to allow blocking on
|
|
|
|
* completions without the risk of the completion disappearing
|
|
|
|
* meanwhile.
|
|
|
|
*/
|
|
|
|
struct kref ref;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @flip_done:
|
|
|
|
*
|
|
|
|
* Will be signaled when the hardware has flipped to the new set of
|
|
|
|
* buffers. Signals at the same time as when the drm event for this
|
|
|
|
* commit is sent to userspace, or when an out-fence is singalled. Note
|
|
|
|
* that for most hardware, in most cases this happens after @hw_done is
|
|
|
|
* signalled.
|
|
|
|
*/
|
|
|
|
struct completion flip_done;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @hw_done:
|
|
|
|
*
|
|
|
|
* Will be signalled when all hw register changes for this commit have
|
|
|
|
* been written out. Especially when disabling a pipe this can be much
|
|
|
|
* later than than @flip_done, since that can signal already when the
|
|
|
|
* screen goes black, whereas to fully shut down a pipe more register
|
|
|
|
* I/O is required.
|
|
|
|
*
|
|
|
|
* Note that this does not need to include separately reference-counted
|
|
|
|
* resources like backing storage buffer pinning, or runtime pm
|
|
|
|
* management.
|
|
|
|
*/
|
|
|
|
struct completion hw_done;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @cleanup_done:
|
|
|
|
*
|
|
|
|
* Will be signalled after old buffers have been cleaned up by calling
|
|
|
|
* drm_atomic_helper_cleanup_planes(). Since this can only happen after
|
|
|
|
* a vblank wait completed it might be a bit later. This completion is
|
|
|
|
* useful to throttle updates and avoid hardware updates getting ahead
|
|
|
|
* of the buffer cleanup too much.
|
|
|
|
*/
|
|
|
|
struct completion cleanup_done;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @commit_entry:
|
|
|
|
*
|
|
|
|
* Entry on the per-CRTC commit_list. Protected by crtc->commit_lock.
|
|
|
|
*/
|
|
|
|
struct list_head commit_entry;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @event:
|
|
|
|
*
|
|
|
|
* &drm_pending_vblank_event pointer to clean up private events.
|
|
|
|
*/
|
|
|
|
struct drm_pending_vblank_event *event;
|
|
|
|
};
|
|
|
|
|
2016-06-01 22:06:33 +00:00
|
|
|
struct __drm_planes_state {
|
|
|
|
struct drm_plane *ptr;
|
|
|
|
struct drm_plane_state *state;
|
|
|
|
};
|
|
|
|
|
2016-06-01 22:06:34 +00:00
|
|
|
struct __drm_crtcs_state {
|
|
|
|
struct drm_crtc *ptr;
|
|
|
|
struct drm_crtc_state *state;
|
2016-06-08 12:19:00 +00:00
|
|
|
struct drm_crtc_commit *commit;
|
2016-06-01 22:06:34 +00:00
|
|
|
};
|
|
|
|
|
2016-06-01 22:06:32 +00:00
|
|
|
struct __drm_connnectors_state {
|
|
|
|
struct drm_connector *ptr;
|
|
|
|
struct drm_connector_state *state;
|
|
|
|
};
|
|
|
|
|
2014-07-25 19:30:38 +00:00
|
|
|
/**
|
2015-03-11 14:23:09 +00:00
|
|
|
* struct drm_atomic_state - the global state object for atomic updates
|
2014-07-25 19:30:38 +00:00
|
|
|
* @dev: parent DRM device
|
2014-12-18 21:01:56 +00:00
|
|
|
* @allow_modeset: allow full modeset
|
2015-12-04 08:46:01 +00:00
|
|
|
* @legacy_cursor_update: hint to enforce legacy cursor IOCTL semantics
|
2016-03-03 09:17:39 +00:00
|
|
|
* @legacy_set_config: Disable conflicting encoders instead of failing with -EINVAL.
|
2016-06-01 22:06:33 +00:00
|
|
|
* @planes: pointer to array of structures with per-plane data
|
2014-07-25 19:30:38 +00:00
|
|
|
* @crtcs: pointer to array of CRTC pointers
|
2014-11-19 17:38:08 +00:00
|
|
|
* @num_connector: size of the @connectors and @connector_states arrays
|
2016-06-01 22:06:32 +00:00
|
|
|
* @connectors: pointer to array of structures with per-connector data
|
2014-07-25 19:30:38 +00:00
|
|
|
* @acquire_ctx: acquire context for this atomic modeset state update
|
|
|
|
*/
|
|
|
|
struct drm_atomic_state {
|
|
|
|
struct drm_device *dev;
|
2014-12-18 21:01:56 +00:00
|
|
|
bool allow_modeset : 1;
|
2015-01-22 15:36:23 +00:00
|
|
|
bool legacy_cursor_update : 1;
|
2016-03-03 09:17:39 +00:00
|
|
|
bool legacy_set_config : 1;
|
2016-06-01 22:06:33 +00:00
|
|
|
struct __drm_planes_state *planes;
|
2016-06-01 22:06:34 +00:00
|
|
|
struct __drm_crtcs_state *crtcs;
|
2014-11-19 17:38:08 +00:00
|
|
|
int num_connector;
|
2016-06-01 22:06:32 +00:00
|
|
|
struct __drm_connnectors_state *connectors;
|
2014-07-25 19:30:38 +00:00
|
|
|
|
|
|
|
struct drm_modeset_acquire_ctx *acquire_ctx;
|
2016-06-08 12:19:00 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @commit_work:
|
|
|
|
*
|
|
|
|
* Work item which can be used by the driver or helpers to execute the
|
|
|
|
* commit without blocking.
|
|
|
|
*/
|
|
|
|
struct work_struct commit_work;
|
2014-07-25 19:30:38 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2008-11-07 22:05:41 +00:00
|
|
|
/**
|
2014-10-27 15:54:27 +00:00
|
|
|
* struct drm_mode_set - new values for a CRTC config change
|
2011-11-07 20:03:19 +00: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-07 22:05:41 +00:00
|
|
|
*
|
|
|
|
* Represents a single crtc the connectors that it drives with what mode
|
|
|
|
* and from which framebuffer it scans out from.
|
|
|
|
*
|
|
|
|
* This is used to set modes.
|
|
|
|
*/
|
|
|
|
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;
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
2011-11-07 20:03:20 +00:00
|
|
|
* struct drm_mode_config_funcs - basic driver provided mode setting functions
|
|
|
|
*
|
|
|
|
* Some global (i.e. not per-CRTC, connector, etc) mode setting functions that
|
|
|
|
* involve drivers.
|
2008-11-07 22:05:41 +00:00
|
|
|
*/
|
|
|
|
struct drm_mode_config_funcs {
|
2015-12-04 08:46:02 +00:00
|
|
|
/**
|
|
|
|
* @fb_create:
|
|
|
|
*
|
|
|
|
* Create a new framebuffer object. The core does basic checks on the
|
|
|
|
* requested metadata, but most of that is left to the driver. See
|
|
|
|
* struct &drm_mode_fb_cmd2 for details.
|
|
|
|
*
|
2015-12-08 08:49:19 +00:00
|
|
|
* If the parameters are deemed valid and the backing storage objects in
|
|
|
|
* the underlying memory manager all exist, then the driver allocates
|
|
|
|
* a new &drm_framebuffer structure, subclassed to contain
|
|
|
|
* driver-specific information (like the internal native buffer object
|
|
|
|
* references). It also needs to fill out all relevant metadata, which
|
|
|
|
* should be done by calling drm_helper_mode_fill_fb_struct().
|
|
|
|
*
|
|
|
|
* The initialization is finalized by calling drm_framebuffer_init(),
|
|
|
|
* which registers the framebuffer and makes it accessible to other
|
|
|
|
* threads.
|
|
|
|
*
|
2015-12-04 08:46:02 +00:00
|
|
|
* RETURNS:
|
|
|
|
*
|
|
|
|
* A new framebuffer with an initial reference count of 1 or a negative
|
|
|
|
* error code encoded with ERR_PTR().
|
|
|
|
*/
|
2011-11-07 20:03:20 +00:00
|
|
|
struct drm_framebuffer *(*fb_create)(struct drm_device *dev,
|
|
|
|
struct drm_file *file_priv,
|
2015-11-11 17:11:29 +00:00
|
|
|
const struct drm_mode_fb_cmd2 *mode_cmd);
|
2015-12-04 08:46:02 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @output_poll_changed:
|
|
|
|
*
|
|
|
|
* Callback used by helpers to inform the driver of output configuration
|
|
|
|
* changes.
|
|
|
|
*
|
|
|
|
* Drivers implementing fbdev emulation with the helpers can call
|
|
|
|
* drm_fb_helper_hotplug_changed from this hook to inform the fbdev
|
|
|
|
* helper of output changes.
|
|
|
|
*
|
|
|
|
* FIXME:
|
|
|
|
*
|
|
|
|
* Except that there's no vtable for device-level helper callbacks
|
|
|
|
* there's no reason this is a core function.
|
|
|
|
*/
|
2010-05-07 06:42:51 +00:00
|
|
|
void (*output_poll_changed)(struct drm_device *dev);
|
2014-07-25 19:30:38 +00:00
|
|
|
|
2015-12-04 08:46:02 +00:00
|
|
|
/**
|
|
|
|
* @atomic_check:
|
|
|
|
*
|
|
|
|
* This is the only hook to validate an atomic modeset update. This
|
|
|
|
* function must reject any modeset and state changes which the hardware
|
|
|
|
* or driver doesn't support. This includes but is of course not limited
|
|
|
|
* to:
|
|
|
|
*
|
|
|
|
* - Checking that the modes, framebuffers, scaling and placement
|
|
|
|
* requirements and so on are within the limits of the hardware.
|
|
|
|
*
|
|
|
|
* - Checking that any hidden shared resources are not oversubscribed.
|
|
|
|
* This can be shared PLLs, shared lanes, overall memory bandwidth,
|
|
|
|
* display fifo space (where shared between planes or maybe even
|
|
|
|
* CRTCs).
|
|
|
|
*
|
|
|
|
* - Checking that virtualized resources exported to userspace are not
|
|
|
|
* oversubscribed. For various reasons it can make sense to expose
|
|
|
|
* more planes, crtcs or encoders than which are physically there. One
|
|
|
|
* example is dual-pipe operations (which generally should be hidden
|
|
|
|
* from userspace if when lockstepped in hardware, exposed otherwise),
|
|
|
|
* where a plane might need 1 hardware plane (if it's just on one
|
|
|
|
* pipe), 2 hardware planes (when it spans both pipes) or maybe even
|
|
|
|
* shared a hardware plane with a 2nd plane (if there's a compatible
|
|
|
|
* plane requested on the area handled by the other pipe).
|
|
|
|
*
|
|
|
|
* - Check that any transitional state is possible and that if
|
|
|
|
* requested, the update can indeed be done in the vblank period
|
|
|
|
* without temporarily disabling some functions.
|
|
|
|
*
|
|
|
|
* - Check any other constraints the driver or hardware might have.
|
|
|
|
*
|
|
|
|
* - This callback also needs to correctly fill out the &drm_crtc_state
|
|
|
|
* in this update to make sure that drm_atomic_crtc_needs_modeset()
|
|
|
|
* reflects the nature of the possible update and returns true if and
|
|
|
|
* only if the update cannot be applied without tearing within one
|
|
|
|
* vblank on that CRTC. The core uses that information to reject
|
|
|
|
* updates which require a full modeset (i.e. blanking the screen, or
|
|
|
|
* at least pausing updates for a substantial amount of time) if
|
|
|
|
* userspace has disallowed that in its request.
|
|
|
|
*
|
|
|
|
* - The driver also does not need to repeat basic input validation
|
|
|
|
* like done for the corresponding legacy entry points. The core does
|
|
|
|
* that before calling this hook.
|
|
|
|
*
|
|
|
|
* See the documentation of @atomic_commit for an exhaustive list of
|
|
|
|
* error conditions which don't have to be checked at the
|
|
|
|
* ->atomic_check() stage?
|
|
|
|
*
|
|
|
|
* See the documentation for struct &drm_atomic_state for how exactly
|
|
|
|
* an atomic modeset update is described.
|
|
|
|
*
|
|
|
|
* Drivers using the atomic helpers can implement this hook using
|
|
|
|
* drm_atomic_helper_check(), or one of the exported sub-functions of
|
|
|
|
* it.
|
|
|
|
*
|
|
|
|
* RETURNS:
|
|
|
|
*
|
|
|
|
* 0 on success or one of the below negative error codes:
|
|
|
|
*
|
|
|
|
* - -EINVAL, if any of the above constraints are violated.
|
|
|
|
*
|
|
|
|
* - -EDEADLK, when returned from an attempt to acquire an additional
|
|
|
|
* &drm_modeset_lock through drm_modeset_lock().
|
|
|
|
*
|
|
|
|
* - -ENOMEM, if allocating additional state sub-structures failed due
|
|
|
|
* to lack of memory.
|
|
|
|
*
|
|
|
|
* - -EINTR, -EAGAIN or -ERESTARTSYS, if the IOCTL should be restarted.
|
|
|
|
* This can either be due to a pending signal, or because the driver
|
|
|
|
* needs to completely bail out to recover from an exceptional
|
|
|
|
* situation like a GPU hang. From a userspace point all errors are
|
|
|
|
* treated equally.
|
|
|
|
*/
|
2014-07-25 19:30:38 +00:00
|
|
|
int (*atomic_check)(struct drm_device *dev,
|
2015-12-04 08:46:02 +00:00
|
|
|
struct drm_atomic_state *state);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @atomic_commit:
|
|
|
|
*
|
|
|
|
* This is the only hook to commit an atomic modeset update. The core
|
|
|
|
* guarantees that @atomic_check has been called successfully before
|
|
|
|
* calling this function, and that nothing has been changed in the
|
|
|
|
* interim.
|
|
|
|
*
|
|
|
|
* See the documentation for struct &drm_atomic_state for how exactly
|
|
|
|
* an atomic modeset update is described.
|
|
|
|
*
|
|
|
|
* Drivers using the atomic helpers can implement this hook using
|
|
|
|
* drm_atomic_helper_commit(), or one of the exported sub-functions of
|
|
|
|
* it.
|
|
|
|
*
|
2016-04-26 14:11:34 +00:00
|
|
|
* Nonblocking commits (as indicated with the nonblock parameter) must
|
2015-12-04 08:46:02 +00:00
|
|
|
* do any preparatory work which might result in an unsuccessful commit
|
|
|
|
* in the context of this callback. The only exceptions are hardware
|
|
|
|
* errors resulting in -EIO. But even in that case the driver must
|
|
|
|
* ensure that the display pipe is at least running, to avoid
|
|
|
|
* compositors crashing when pageflips don't work. Anything else,
|
|
|
|
* specifically committing the update to the hardware, should be done
|
|
|
|
* without blocking the caller. For updates which do not require a
|
|
|
|
* modeset this must be guaranteed.
|
|
|
|
*
|
|
|
|
* The driver must wait for any pending rendering to the new
|
|
|
|
* framebuffers to complete before executing the flip. It should also
|
|
|
|
* wait for any pending rendering from other drivers if the underlying
|
2016-04-26 14:11:34 +00:00
|
|
|
* buffer is a shared dma-buf. Nonblocking commits must not wait for
|
2015-12-04 08:46:02 +00:00
|
|
|
* rendering in the context of this callback.
|
|
|
|
*
|
|
|
|
* An application can request to be notified when the atomic commit has
|
|
|
|
* completed. These events are per-CRTC and can be distinguished by the
|
|
|
|
* CRTC index supplied in &drm_event to userspace.
|
|
|
|
*
|
|
|
|
* The drm core will supply a struct &drm_event in the event
|
|
|
|
* member of each CRTC's &drm_crtc_state structure. 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 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.
|
|
|
|
*
|
|
|
|
* NOTE:
|
|
|
|
*
|
|
|
|
* Drivers are not allowed to shut down any display pipe successfully
|
|
|
|
* enabled through an atomic commit on their own. Doing so can result in
|
|
|
|
* compositors crashing if a page flip is suddenly rejected because the
|
|
|
|
* pipe is off.
|
|
|
|
*
|
|
|
|
* RETURNS:
|
|
|
|
*
|
|
|
|
* 0 on success or one of the below negative error codes:
|
|
|
|
*
|
2016-04-26 14:11:34 +00:00
|
|
|
* - -EBUSY, if a nonblocking updated is requested and there is
|
2015-12-04 08:46:02 +00:00
|
|
|
* an earlier updated pending. Drivers are allowed to support a queue
|
|
|
|
* of outstanding updates, but currently no driver supports that.
|
|
|
|
* Note that drivers must wait for preceding updates to complete if a
|
|
|
|
* synchronous update is requested, they are not allowed to fail the
|
|
|
|
* commit in that case.
|
|
|
|
*
|
|
|
|
* - -ENOMEM, if the driver failed to allocate memory. Specifically
|
|
|
|
* this can happen when trying to pin framebuffers, which must only
|
|
|
|
* be done when committing the state.
|
|
|
|
*
|
|
|
|
* - -ENOSPC, as a refinement of the more generic -ENOMEM to indicate
|
|
|
|
* that the driver has run out of vram, iommu space or similar GPU
|
|
|
|
* address space needed for framebuffer.
|
|
|
|
*
|
|
|
|
* - -EIO, if the hardware completely died.
|
|
|
|
*
|
|
|
|
* - -EINTR, -EAGAIN or -ERESTARTSYS, if the IOCTL should be restarted.
|
|
|
|
* This can either be due to a pending signal, or because the driver
|
|
|
|
* needs to completely bail out to recover from an exceptional
|
|
|
|
* situation like a GPU hang. From a userspace point of view all errors are
|
|
|
|
* treated equally.
|
|
|
|
*
|
|
|
|
* This list is exhaustive. Specifically this hook is not allowed to
|
|
|
|
* return -EINVAL (any invalid requests should be caught in
|
|
|
|
* @atomic_check) or -EDEADLK (this function must not acquire
|
|
|
|
* additional modeset locks).
|
|
|
|
*/
|
2014-07-25 19:30:38 +00:00
|
|
|
int (*atomic_commit)(struct drm_device *dev,
|
2015-12-04 08:46:02 +00:00
|
|
|
struct drm_atomic_state *state,
|
2016-04-26 14:11:34 +00:00
|
|
|
bool nonblock);
|
2015-12-04 08:46:02 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @atomic_state_alloc:
|
|
|
|
*
|
|
|
|
* This optional hook can be used by drivers that want to subclass struct
|
|
|
|
* &drm_atomic_state to be able to track their own driver-private global
|
|
|
|
* state easily. If this hook is implemented, drivers must also
|
|
|
|
* implement @atomic_state_clear and @atomic_state_free.
|
|
|
|
*
|
|
|
|
* RETURNS:
|
|
|
|
*
|
|
|
|
* A new &drm_atomic_state on success or NULL on failure.
|
|
|
|
*/
|
2015-05-18 08:06:40 +00:00
|
|
|
struct drm_atomic_state *(*atomic_state_alloc)(struct drm_device *dev);
|
2015-12-04 08:46:02 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @atomic_state_clear:
|
|
|
|
*
|
|
|
|
* This hook must clear any driver private state duplicated into the
|
|
|
|
* passed-in &drm_atomic_state. This hook is called when the caller
|
|
|
|
* encountered a &drm_modeset_lock deadlock and needs to drop all
|
|
|
|
* already acquired locks as part of the deadlock avoidance dance
|
|
|
|
* implemented in drm_modeset_lock_backoff().
|
|
|
|
*
|
|
|
|
* Any duplicated state must be invalidated since a concurrent atomic
|
|
|
|
* update might change it, and the drm atomic interfaces always apply
|
|
|
|
* updates as relative changes to the current state.
|
|
|
|
*
|
|
|
|
* Drivers that implement this must call drm_atomic_state_default_clear()
|
|
|
|
* to clear common state.
|
|
|
|
*/
|
2015-05-18 08:06:40 +00:00
|
|
|
void (*atomic_state_clear)(struct drm_atomic_state *state);
|
2015-12-04 08:46:02 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @atomic_state_free:
|
|
|
|
*
|
|
|
|
* This hook needs driver private resources and the &drm_atomic_state
|
|
|
|
* itself. Note that the core first calls drm_atomic_state_clear() to
|
|
|
|
* avoid code duplicate between the clear and free hooks.
|
|
|
|
*
|
|
|
|
* Drivers that implement this must call drm_atomic_state_default_free()
|
|
|
|
* to release common resources.
|
|
|
|
*/
|
2015-05-18 08:06:40 +00:00
|
|
|
void (*atomic_state_free)(struct drm_atomic_state *state);
|
2008-11-07 22:05:41 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
2014-10-27 19:19:38 +00:00
|
|
|
* struct drm_mode_config - Mode configuration control structure
|
2011-11-07 20:03:22 +00:00
|
|
|
* @mutex: mutex protecting KMS related lists and structures
|
2014-10-27 19:19:38 +00:00
|
|
|
* @connection_mutex: ww mutex protecting connector state and routing
|
|
|
|
* @acquire_ctx: global implicit acquire context used by atomic drivers for
|
2015-12-04 08:46:01 +00:00
|
|
|
* legacy IOCTLs
|
2014-10-27 19:19:38 +00:00
|
|
|
* @fb_lock: mutex to protect fb state and lists
|
2011-11-07 20:03:22 +00:00
|
|
|
* @num_fb: number of fbs available
|
|
|
|
* @fb_list: list of framebuffers available
|
|
|
|
* @num_encoder: number of encoders on this device
|
|
|
|
* @encoder_list: list of encoder objects
|
2014-10-27 19:19:38 +00:00
|
|
|
* @num_overlay_plane: number of overlay planes on this device
|
|
|
|
* @num_total_plane: number of universal (i.e. with primary/curso) planes on this device
|
|
|
|
* @plane_list: list of plane objects
|
2011-11-07 20:03:22 +00:00
|
|
|
* @num_crtc: number of CRTCs on this device
|
|
|
|
* @crtc_list: list of CRTC objects
|
2014-10-27 19:19:38 +00:00
|
|
|
* @property_list: list of property objects
|
2011-11-07 20:03:22 +00:00
|
|
|
* @min_width: minimum pixel width on this device
|
|
|
|
* @min_height: minimum pixel height on this device
|
|
|
|
* @max_width: maximum pixel width on this device
|
|
|
|
* @max_height: maximum pixel height on this device
|
|
|
|
* @funcs: core driver provided mode setting functions
|
|
|
|
* @fb_base: base address of the framebuffer
|
2014-10-27 19:19:38 +00:00
|
|
|
* @poll_enabled: track polling support for this device
|
|
|
|
* @poll_running: track polling status for this device
|
2016-05-31 21:11:10 +00:00
|
|
|
* @delayed_event: track delayed poll uevent deliver for this device
|
2011-11-07 20:03:22 +00:00
|
|
|
* @output_poll_work: delayed work for polling in process context
|
2014-10-27 19:19:38 +00:00
|
|
|
* @property_blob_list: list of all the blob property objects
|
2015-04-20 18:22:54 +00:00
|
|
|
* @blob_lock: mutex for blob property allocation and management
|
2011-11-07 20:03:22 +00:00
|
|
|
* @*_property: core property tracking
|
2014-10-27 19:19:38 +00:00
|
|
|
* @preferred_depth: preferred RBG pixel depth, used by fb helpers
|
|
|
|
* @prefer_shadow: hint to userspace to prefer shadow-fb rendering
|
|
|
|
* @cursor_width: hint to userspace for max cursor width
|
|
|
|
* @cursor_height: hint to userspace for max cursor height
|
drm/atomic-helper: nonblocking commit support
Design ideas:
- split up the actual commit into different phases, and have
completions for each of them. This will be useful for the future
when we want to interleave phases much more aggressively, for e.g.
queue depth > 1. For not it's just a minimal optimization compared
to current common nonblocking implementation patterns from drivers,
which all stall for the entire commit to complete, including vblank
waits and cleanups.
- Extract a separate atomic_commit_hw hook since that's the part most
drivers will need to overwrite, hopefully allowing even more shared
code.
- Enforce EBUSY seamntics by attaching one of the completions to the
flip_done vblank event. Side benefit of forcing atomic drivers using
these helpers to implement event handlign at least semi-correct. I'm
evil that way ;-)
- Ridiculously modular, as usual.
- The main tracking unit for a commit stays struct drm_atomic_state,
and the ownership rules for that are unchanged. Ownership still
gets transferred to the driver (and subsequently to the worker) on
successful commits. What is added is a small, per-crtc, refcounted
structure to track pending commits called struct drm_crtc_commit.
No actual state is attached to that though, it's purely for ordering
and waiting.
- Dependencies are implicitly handled by assuming that any CRTC part
of &drm_atomic_state is a dependency, and that the current commit
must wait for any commits to complete on those CRTC. This way
drivers can easily add more depencies using
drm_atomic_get_crtc_state(), which is very natural since in most
case a dependency exists iff there's some bit of state that needs to
be cross checked.
Removing depencies is not possible, drivers simply need to be
careful to not include every CRTC in a commit if that's not
necessary. Which is a good idea anyway, since that also avoids
ww_mutex lock contention.
- Queue depth > 1 sees some prep work in this patch by adding a stall
paramater to drm_atomic_helper_swap_states(). To be able to push
commits entirely free-standing and in a deeper queue through the
back-end the driver must not access any obj->state pointers. This
means we need to track the old state in drm_atomic_state (much
easier with the consolidated arrays), and pass them all explicitly
to driver backends (this will be serious amounts of churn).
Once that's done stall can be set to false in swap_states.
v2: Dont ask for flip_done signalling when the CRTC is off and stays
off: Drivers don't handle events in that case. Instead complete right
away. This way future commits don't need to have special-case logic,
but can keep blocking for the flip_done completion.
v3: Tons of fixes:
- Stall for preceeding commit for real, not the current one by
accident.
- Add WARN_ON in case drivers don't fire the drm event.
- Don't double-free drm events.
v4: Make legacy cursor not stall.
v5: Extend the helper hook to cover the entire commit tail. Some
drivers need special code for cleanup and vblank waiting, this makes
it a bit more useful. Inspired by the rockchip driver.
v6: Add WARN_ON to catch drivers who forget to send out the
drm event.
v7: Fixup the stalls in swap_state for real!!
v8:
- Fixup trailing whitespace, spotted by Maarten.
- Actually wait for flip_done in cleanup_done, like the comment says
we should do. Thanks a lot for Tomeu for helping with debugging this
on.
v9: Now with awesome kerneldoc!
v10: Split out drm_crtc_commit tracking infrastructure.
v:
- Add missing static (Gustavo).
- Split out the sync functions, only do the actual nonblocking
logic in this patch (Maarten).
Cc: Gustavo Padovan <gustavo.padovan@collabora.co.uk>
Tested-by: Tomeu Vizoso <tomeu.vizoso@collabora.com>
Cc: Maarten Lankhorst <maarten.lankhorst@linux.intel.com>
Cc: Tomeu Vizoso <tomeu.vizoso@gmail.com>
Cc: Daniel Stone <daniels@collabora.com>
Tested-by: Liviu Dudau <Liviu.Dudau@arm.com>
Reviewed-by: Maarten Lankhorst <maarten.lankhorst@linux.intel.com>
Testcase: igt/kms_flip/*
Testcase: igt/kms_cursor*
Testcase: igt/kms*plane*
Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>
Link: http://patchwork.freedesktop.org/patch/msgid/1465388359-8070-10-git-send-email-daniel.vetter@ffwll.ch
2016-06-08 12:19:02 +00:00
|
|
|
* @helper_private: mid-layer private data
|
2008-11-07 22:05:41 +00:00
|
|
|
*
|
2011-11-07 20:03:22 +00:00
|
|
|
* Core mode resource tracking structure. All CRTC, encoders, and connectors
|
|
|
|
* enumerated by the driver are added here, as are global properties. Some
|
|
|
|
* global restrictions are also here, e.g. dimension restrictions.
|
2008-11-07 22:05:41 +00:00
|
|
|
*/
|
|
|
|
struct drm_mode_config {
|
2009-01-19 07:21:45 +00:00
|
|
|
struct mutex mutex; /* protects configuration (mode lists etc.) */
|
2013-11-19 17:10:12 +00:00
|
|
|
struct drm_modeset_lock connection_mutex; /* protects connector->encoder and encoder->crtc links */
|
|
|
|
struct drm_modeset_acquire_ctx *acquire_ctx; /* for legacy _lock_all() / _unlock_all() */
|
2016-05-31 21:11:10 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @idr_mutex:
|
|
|
|
*
|
|
|
|
* Mutex for KMS ID allocation and management. Protects both @crtc_idr
|
|
|
|
* and @tile_idr.
|
|
|
|
*/
|
|
|
|
struct mutex idr_mutex;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @crtc_idr:
|
|
|
|
*
|
|
|
|
* Main KMS ID tracking object. Use this idr for all IDs, fb, crtc,
|
|
|
|
* connector, modes - just makes life easier to have only one.
|
|
|
|
*/
|
|
|
|
struct idr crtc_idr;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @tile_idr:
|
|
|
|
*
|
|
|
|
* Use this idr for allocating new IDs for tiled sinks like use in some
|
|
|
|
* high-res DP MST screens.
|
|
|
|
*/
|
|
|
|
struct idr tile_idr;
|
drm: revamp locking around fb creation/destruction
Well, at least step 1. The goal here is that framebuffer objects can
survive outside of the mode_config lock, with just a reference held
as protection. The first step to get there is to introduce a special
fb_lock which protects fb lookup, creation and destruction, to make
them appear atomic.
This new fb_lock can nest within the mode_config lock. But the idea is
(once the reference counting part is completed) that we only quickly
take that fb_lock to lookup a framebuffer and grab a reference,
without any other locks involved.
vmwgfx is the only driver which does framebuffer lookups itself, also
wrap those calls to drm_mode_object_find with the new lock.
Also protect the fb_list walking in i915 and omapdrm with the new lock.
As a slight complication there's also the list of user-created fbs
attached to the file private. The problem now is that at fclose() time
we need to walk that list, eventually do a modeset call to remove the
fb from active usage (and are required to be able to take the
mode_config lock), but in the end we need to grab the new fb_lock to
remove the fb from the list. The easiest solution is to add another
mutex to protect this per-file list.
Currently that new fbs_lock nests within the modeset locks and so
appears redudant. But later patches will switch around this sequence
so that taking the modeset locks in the fb destruction path is
optional in the fastpath. Ultimately the goal is that addfb and rmfb
do not require the mode_config lock, since otherwise they have the
potential to introduce stalls in the pageflip sequence of a compositor
(if the compositor e.g. switches to a fullscreen client or if it
enables a plane). But that requires a few more steps and hoops to jump
through.
Note that framebuffer creation/destruction is now double-protected -
once by the fb_lock and in parts by the idr_lock. The later would be
unnecessariy if framebuffers would have their own idr allocator. But
that's material for another patch (series).
v2: Properly initialize the fb->filp_head list in _init, otherwise the
newly added WARN to check whether the fb isn't on a fpriv list any
more will fail for driver-private objects.
v3: Fixup two error-case unlock bugs spotted by Richard Wilbur.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-10 20:19:18 +00:00
|
|
|
|
2014-10-27 19:19:38 +00:00
|
|
|
struct mutex fb_lock; /* proctects global and per-file fb lists */
|
2008-11-07 22:05:41 +00:00
|
|
|
int num_fb;
|
|
|
|
struct list_head fb_list;
|
drm: revamp locking around fb creation/destruction
Well, at least step 1. The goal here is that framebuffer objects can
survive outside of the mode_config lock, with just a reference held
as protection. The first step to get there is to introduce a special
fb_lock which protects fb lookup, creation and destruction, to make
them appear atomic.
This new fb_lock can nest within the mode_config lock. But the idea is
(once the reference counting part is completed) that we only quickly
take that fb_lock to lookup a framebuffer and grab a reference,
without any other locks involved.
vmwgfx is the only driver which does framebuffer lookups itself, also
wrap those calls to drm_mode_object_find with the new lock.
Also protect the fb_list walking in i915 and omapdrm with the new lock.
As a slight complication there's also the list of user-created fbs
attached to the file private. The problem now is that at fclose() time
we need to walk that list, eventually do a modeset call to remove the
fb from active usage (and are required to be able to take the
mode_config lock), but in the end we need to grab the new fb_lock to
remove the fb from the list. The easiest solution is to add another
mutex to protect this per-file list.
Currently that new fbs_lock nests within the modeset locks and so
appears redudant. But later patches will switch around this sequence
so that taking the modeset locks in the fb destruction path is
optional in the fastpath. Ultimately the goal is that addfb and rmfb
do not require the mode_config lock, since otherwise they have the
potential to introduce stalls in the pageflip sequence of a compositor
(if the compositor e.g. switches to a fullscreen client or if it
enables a plane). But that requires a few more steps and hoops to jump
through.
Note that framebuffer creation/destruction is now double-protected -
once by the fb_lock and in parts by the idr_lock. The later would be
unnecessariy if framebuffers would have their own idr allocator. But
that's material for another patch (series).
v2: Properly initialize the fb->filp_head list in _init, otherwise the
newly added WARN to check whether the fb isn't on a fpriv list any
more will fail for driver-private objects.
v3: Fixup two error-case unlock bugs spotted by Richard Wilbur.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-10 20:19:18 +00:00
|
|
|
|
2016-07-15 19:47:59 +00:00
|
|
|
/**
|
|
|
|
* @num_connector: Number of connectors on this device.
|
|
|
|
*/
|
2008-11-07 22:05:41 +00:00
|
|
|
int num_connector;
|
2016-07-15 19:47:59 +00:00
|
|
|
/**
|
|
|
|
* @connector_ida: ID allocator for connector indices.
|
|
|
|
*/
|
2016-02-17 07:32:05 +00:00
|
|
|
struct ida connector_ida;
|
2016-07-15 19:47:59 +00:00
|
|
|
/**
|
|
|
|
* @connector_list: List of connector objects.
|
|
|
|
*/
|
2008-11-07 22:05:41 +00:00
|
|
|
struct list_head connector_list;
|
|
|
|
int num_encoder;
|
|
|
|
struct list_head encoder_list;
|
2014-04-01 22:22:30 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Track # of overlay planes separately from # of total planes. By
|
|
|
|
* default we only advertise overlay planes to userspace; if userspace
|
|
|
|
* sets the "universal plane" capability bit, we'll go ahead and
|
|
|
|
* expose all planes.
|
|
|
|
*/
|
|
|
|
int num_overlay_plane;
|
|
|
|
int num_total_plane;
|
2011-11-14 22:51:27 +00:00
|
|
|
struct list_head plane_list;
|
2008-11-07 22:05:41 +00:00
|
|
|
|
|
|
|
int num_crtc;
|
|
|
|
struct list_head crtc_list;
|
|
|
|
|
|
|
|
struct list_head property_list;
|
|
|
|
|
|
|
|
int min_width, min_height;
|
|
|
|
int max_width, max_height;
|
2012-05-17 11:27:23 +00:00
|
|
|
const struct drm_mode_config_funcs *funcs;
|
2009-02-02 05:55:45 +00:00
|
|
|
resource_size_t fb_base;
|
2008-11-07 22:05:41 +00:00
|
|
|
|
2010-05-07 06:42:51 +00:00
|
|
|
/* output poll support */
|
|
|
|
bool poll_enabled;
|
2012-10-23 18:23:36 +00:00
|
|
|
bool poll_running;
|
2015-01-21 07:45:21 +00:00
|
|
|
bool delayed_event;
|
2010-07-20 20:09:02 +00:00
|
|
|
struct delayed_work output_poll_work;
|
2010-05-07 06:42:51 +00:00
|
|
|
|
2015-04-20 18:22:54 +00:00
|
|
|
struct mutex blob_lock;
|
|
|
|
|
2008-11-07 22:05:41 +00:00
|
|
|
/* pointers to standard properties */
|
|
|
|
struct list_head property_blob_list;
|
2016-07-15 19:48:00 +00:00
|
|
|
/**
|
|
|
|
* @edid_property: Default connector property to hold the EDID of the
|
|
|
|
* currently connected sink, if any.
|
|
|
|
*/
|
2008-11-07 22:05:41 +00:00
|
|
|
struct drm_property *edid_property;
|
2016-07-15 19:48:00 +00:00
|
|
|
/**
|
|
|
|
* @dpms_property: Default connector property to control the
|
|
|
|
* connector's DPMS state.
|
|
|
|
*/
|
2008-11-07 22:05:41 +00:00
|
|
|
struct drm_property *dpms_property;
|
2016-07-15 19:48:00 +00:00
|
|
|
/**
|
|
|
|
* @path_property: Default connector property to hold the DP MST path
|
|
|
|
* for the port.
|
|
|
|
*/
|
2014-06-05 04:01:31 +00:00
|
|
|
struct drm_property *path_property;
|
2016-07-15 19:48:00 +00:00
|
|
|
/**
|
|
|
|
* @tile_property: Default connector property to store the tile
|
|
|
|
* position of a tiled screen, for sinks which need to be driven with
|
|
|
|
* multiple CRTCs.
|
|
|
|
*/
|
2014-10-20 06:30:50 +00:00
|
|
|
struct drm_property *tile_property;
|
2016-07-15 19:48:00 +00:00
|
|
|
/**
|
|
|
|
* @plane_type_property: Default plane property to differentiate
|
|
|
|
* CURSOR, PRIMARY and OVERLAY legacy uses of planes.
|
|
|
|
*/
|
2014-04-02 00:16:57 +00:00
|
|
|
struct drm_property *plane_type_property;
|
2016-07-15 19:48:00 +00:00
|
|
|
/**
|
|
|
|
* @rotation_property: Optional property for planes or CRTCs to specifiy
|
|
|
|
* rotation.
|
|
|
|
*/
|
2014-08-05 05:56:54 +00:00
|
|
|
struct drm_property *rotation_property;
|
2016-07-15 19:48:00 +00:00
|
|
|
/**
|
|
|
|
* @prop_src_x: Default atomic plane property for the plane source
|
|
|
|
* position in the connected &drm_framebuffer.
|
|
|
|
*/
|
2014-12-18 21:01:53 +00:00
|
|
|
struct drm_property *prop_src_x;
|
2016-07-15 19:48:00 +00:00
|
|
|
/**
|
|
|
|
* @prop_src_y: Default atomic plane property for the plane source
|
|
|
|
* position in the connected &drm_framebuffer.
|
|
|
|
*/
|
2014-12-18 21:01:53 +00:00
|
|
|
struct drm_property *prop_src_y;
|
2016-07-15 19:48:00 +00:00
|
|
|
/**
|
|
|
|
* @prop_src_w: Default atomic plane property for the plane source
|
|
|
|
* position in the connected &drm_framebuffer.
|
|
|
|
*/
|
2014-12-18 21:01:53 +00:00
|
|
|
struct drm_property *prop_src_w;
|
2016-07-15 19:48:00 +00:00
|
|
|
/**
|
|
|
|
* @prop_src_h: Default atomic plane property for the plane source
|
|
|
|
* position in the connected &drm_framebuffer.
|
|
|
|
*/
|
2014-12-18 21:01:53 +00:00
|
|
|
struct drm_property *prop_src_h;
|
2016-07-15 19:48:00 +00:00
|
|
|
/**
|
|
|
|
* @prop_crtc_x: Default atomic plane property for the plane destination
|
|
|
|
* position in the &drm_crtc is is being shown on.
|
|
|
|
*/
|
2014-12-18 21:01:53 +00:00
|
|
|
struct drm_property *prop_crtc_x;
|
2016-07-15 19:48:00 +00:00
|
|
|
/**
|
|
|
|
* @prop_crtc_y: Default atomic plane property for the plane destination
|
|
|
|
* position in the &drm_crtc is is being shown on.
|
|
|
|
*/
|
2014-12-18 21:01:53 +00:00
|
|
|
struct drm_property *prop_crtc_y;
|
2016-07-15 19:48:00 +00:00
|
|
|
/**
|
|
|
|
* @prop_crtc_w: Default atomic plane property for the plane destination
|
|
|
|
* position in the &drm_crtc is is being shown on.
|
|
|
|
*/
|
2014-12-18 21:01:53 +00:00
|
|
|
struct drm_property *prop_crtc_w;
|
2016-07-15 19:48:00 +00:00
|
|
|
/**
|
|
|
|
* @prop_crtc_h: Default atomic plane property for the plane destination
|
|
|
|
* position in the &drm_crtc is is being shown on.
|
|
|
|
*/
|
2014-12-18 21:01:53 +00:00
|
|
|
struct drm_property *prop_crtc_h;
|
2016-07-15 19:48:00 +00:00
|
|
|
/**
|
|
|
|
* @prop_fb_id: Default atomic plane property to specify the
|
|
|
|
* &drm_framebuffer.
|
|
|
|
*/
|
2014-12-18 21:01:53 +00:00
|
|
|
struct drm_property *prop_fb_id;
|
2016-07-15 19:48:00 +00:00
|
|
|
/**
|
|
|
|
* @prop_crtc_id: Default atomic plane property to specify the
|
|
|
|
* &drm_crtc.
|
|
|
|
*/
|
2014-12-18 21:01:53 +00:00
|
|
|
struct drm_property *prop_crtc_id;
|
2016-07-15 19:48:00 +00:00
|
|
|
/**
|
|
|
|
* @prop_active: Default atomic CRTC property to control the active
|
|
|
|
* state, which is the simplified implementation for DPMS in atomic
|
|
|
|
* drivers.
|
|
|
|
*/
|
2015-01-22 15:36:21 +00:00
|
|
|
struct drm_property *prop_active;
|
2016-07-15 19:48:00 +00:00
|
|
|
/**
|
|
|
|
* @prop_mode_id: Default atomic CRTC property to set the mode for a
|
|
|
|
* CRTC. A 0 mode implies that the CRTC is entirely disabled - all
|
|
|
|
* connectors must be of and active must be set to disabled, too.
|
|
|
|
*/
|
2015-05-25 18:11:52 +00:00
|
|
|
struct drm_property *prop_mode_id;
|
2008-11-07 22:05:41 +00:00
|
|
|
|
2016-07-15 19:48:00 +00:00
|
|
|
/**
|
|
|
|
* @dvi_i_subconnector_property: Optional DVI-I property to
|
|
|
|
* differentiate between analog or digital mode.
|
|
|
|
*/
|
2008-11-07 22:05:41 +00:00
|
|
|
struct drm_property *dvi_i_subconnector_property;
|
2016-07-15 19:48:00 +00:00
|
|
|
/**
|
|
|
|
* @dvi_i_select_subconnector_property: Optional DVI-I property to
|
|
|
|
* select between analog or digital mode.
|
|
|
|
*/
|
2008-11-07 22:05:41 +00:00
|
|
|
struct drm_property *dvi_i_select_subconnector_property;
|
|
|
|
|
2016-07-15 19:48:00 +00:00
|
|
|
/**
|
|
|
|
* @tv_subconnector_property: Optional TV property to differentiate
|
|
|
|
* between different TV connector types.
|
|
|
|
*/
|
2008-11-07 22:05:41 +00:00
|
|
|
struct drm_property *tv_subconnector_property;
|
2016-07-15 19:48:00 +00:00
|
|
|
/**
|
|
|
|
* @tv_select_subconnector_property: Optional TV property to select
|
|
|
|
* between different TV connector types.
|
|
|
|
*/
|
2008-11-07 22:05:41 +00:00
|
|
|
struct drm_property *tv_select_subconnector_property;
|
2016-07-15 19:48:00 +00:00
|
|
|
/**
|
|
|
|
* @tv_mode_property: Optional TV property to select
|
|
|
|
* the output TV mode.
|
|
|
|
*/
|
2008-11-07 22:05:41 +00:00
|
|
|
struct drm_property *tv_mode_property;
|
2016-07-15 19:48:00 +00:00
|
|
|
/**
|
|
|
|
* @tv_left_margin_property: Optional TV property to set the left
|
|
|
|
* margin.
|
|
|
|
*/
|
2008-11-07 22:05:41 +00:00
|
|
|
struct drm_property *tv_left_margin_property;
|
2016-07-15 19:48:00 +00:00
|
|
|
/**
|
|
|
|
* @tv_right_margin_property: Optional TV property to set the right
|
|
|
|
* margin.
|
|
|
|
*/
|
2008-11-07 22:05:41 +00:00
|
|
|
struct drm_property *tv_right_margin_property;
|
2016-07-15 19:48:00 +00:00
|
|
|
/**
|
|
|
|
* @tv_top_margin_property: Optional TV property to set the right
|
|
|
|
* margin.
|
|
|
|
*/
|
2008-11-07 22:05:41 +00:00
|
|
|
struct drm_property *tv_top_margin_property;
|
2016-07-15 19:48:00 +00:00
|
|
|
/**
|
|
|
|
* @tv_bottom_margin_property: Optional TV property to set the right
|
|
|
|
* margin.
|
|
|
|
*/
|
2008-11-07 22:05:41 +00:00
|
|
|
struct drm_property *tv_bottom_margin_property;
|
2016-07-15 19:48:00 +00:00
|
|
|
/**
|
|
|
|
* @tv_brightness_property: Optional TV property to set the
|
|
|
|
* brightness.
|
|
|
|
*/
|
2009-08-02 02:19:20 +00:00
|
|
|
struct drm_property *tv_brightness_property;
|
2016-07-15 19:48:00 +00:00
|
|
|
/**
|
|
|
|
* @tv_contrast_property: Optional TV property to set the
|
|
|
|
* contrast.
|
|
|
|
*/
|
2009-08-02 02:19:20 +00:00
|
|
|
struct drm_property *tv_contrast_property;
|
2016-07-15 19:48:00 +00:00
|
|
|
/**
|
|
|
|
* @tv_flicker_reduction_property: Optional TV property to control the
|
|
|
|
* flicker reduction mode.
|
|
|
|
*/
|
2009-08-02 02:19:20 +00:00
|
|
|
struct drm_property *tv_flicker_reduction_property;
|
2016-07-15 19:48:00 +00:00
|
|
|
/**
|
|
|
|
* @tv_overscan_property: Optional TV property to control the overscan
|
|
|
|
* setting.
|
|
|
|
*/
|
2009-08-12 00:30:10 +00:00
|
|
|
struct drm_property *tv_overscan_property;
|
2016-07-15 19:48:00 +00:00
|
|
|
/**
|
|
|
|
* @tv_saturation_property: Optional TV property to set the
|
|
|
|
* saturation.
|
|
|
|
*/
|
2009-08-12 00:30:10 +00:00
|
|
|
struct drm_property *tv_saturation_property;
|
2016-07-15 19:48:00 +00:00
|
|
|
/**
|
|
|
|
* @tv_hue_property: Optional TV property to set the hue.
|
|
|
|
*/
|
2009-08-12 00:30:10 +00:00
|
|
|
struct drm_property *tv_hue_property;
|
2008-11-07 22:05:41 +00:00
|
|
|
|
2016-07-15 19:48:00 +00:00
|
|
|
/**
|
|
|
|
* @scaling_mode_property: Optional connector property to control the
|
|
|
|
* upscaling, mostly used for built-in panels.
|
|
|
|
*/
|
2008-11-07 22:05:41 +00:00
|
|
|
struct drm_property *scaling_mode_property;
|
2016-07-15 19:48:00 +00:00
|
|
|
/**
|
|
|
|
* @aspect_ratio_property: Optional connector property to control the
|
|
|
|
* HDMI infoframe aspect ratio setting.
|
|
|
|
*/
|
2014-06-11 05:16:48 +00:00
|
|
|
struct drm_property *aspect_ratio_property;
|
2016-07-15 19:48:00 +00:00
|
|
|
/**
|
|
|
|
* @degamma_lut_property: Optional CRTC property to set the LUT used to
|
|
|
|
* convert the framebuffer's colors to linear gamma.
|
|
|
|
*/
|
2016-02-26 17:05:00 +00:00
|
|
|
struct drm_property *degamma_lut_property;
|
2016-07-15 19:48:00 +00:00
|
|
|
/**
|
|
|
|
* @degamma_lut_size_property: Optional CRTC property for the size of
|
|
|
|
* the degamma LUT as supported by the driver (read-only).
|
|
|
|
*/
|
2016-02-26 17:05:00 +00:00
|
|
|
struct drm_property *degamma_lut_size_property;
|
2016-07-15 19:48:00 +00:00
|
|
|
/**
|
|
|
|
* @ctm_property: Optional CRTC property to set the
|
|
|
|
* matrix used to convert colors after the lookup in the
|
|
|
|
* degamma LUT.
|
|
|
|
*/
|
2016-02-26 17:05:00 +00:00
|
|
|
struct drm_property *ctm_property;
|
2016-07-15 19:48:00 +00:00
|
|
|
/**
|
|
|
|
* @gamma_lut_property: Optional CRTC property to set the LUT used to
|
|
|
|
* convert the colors, after the CTM matrix, to the gamma space of the
|
|
|
|
* connected screen.
|
|
|
|
*/
|
2016-02-26 17:05:00 +00:00
|
|
|
struct drm_property *gamma_lut_property;
|
2016-07-15 19:48:00 +00:00
|
|
|
/**
|
|
|
|
* @gamma_lut_size_property: Optional CRTC property for the size of the
|
|
|
|
* gamma LUT as supported by the driver (read-only).
|
|
|
|
*/
|
2016-02-26 17:05:00 +00:00
|
|
|
struct drm_property *gamma_lut_size_property;
|
|
|
|
|
2016-07-15 19:48:00 +00:00
|
|
|
/**
|
|
|
|
* @suggested_x_property: Optional connector property with a hint for
|
|
|
|
* the position of the output on the host's screen.
|
|
|
|
*/
|
2014-11-10 00:18:15 +00:00
|
|
|
struct drm_property *suggested_x_property;
|
2016-07-15 19:48:00 +00:00
|
|
|
/**
|
|
|
|
* @suggested_y_property: Optional connector property with a hint for
|
|
|
|
* the position of the output on the host's screen.
|
|
|
|
*/
|
2014-11-10 00:18:15 +00:00
|
|
|
struct drm_property *suggested_y_property;
|
|
|
|
|
2011-09-29 15:20:42 +00:00
|
|
|
/* dumb ioctl parameters */
|
|
|
|
uint32_t preferred_depth, prefer_shadow;
|
2013-07-23 01:50:00 +00:00
|
|
|
|
2016-07-15 19:48:00 +00:00
|
|
|
/**
|
|
|
|
* @async_page_flip: Does this device support async flips on the primary
|
|
|
|
* plane?
|
|
|
|
*/
|
2013-07-23 01:50:00 +00:00
|
|
|
bool async_page_flip;
|
2014-02-12 17:48:23 +00:00
|
|
|
|
2016-05-31 21:11:10 +00:00
|
|
|
/**
|
|
|
|
* @allow_fb_modifiers:
|
|
|
|
*
|
|
|
|
* Whether the driver supports fb modifiers in the ADDFB2.1 ioctl call.
|
|
|
|
*/
|
2015-02-05 14:41:52 +00:00
|
|
|
bool allow_fb_modifiers;
|
|
|
|
|
2014-02-12 17:48:23 +00:00
|
|
|
/* cursor size */
|
|
|
|
uint32_t cursor_width, cursor_height;
|
drm/atomic-helper: nonblocking commit support
Design ideas:
- split up the actual commit into different phases, and have
completions for each of them. This will be useful for the future
when we want to interleave phases much more aggressively, for e.g.
queue depth > 1. For not it's just a minimal optimization compared
to current common nonblocking implementation patterns from drivers,
which all stall for the entire commit to complete, including vblank
waits and cleanups.
- Extract a separate atomic_commit_hw hook since that's the part most
drivers will need to overwrite, hopefully allowing even more shared
code.
- Enforce EBUSY seamntics by attaching one of the completions to the
flip_done vblank event. Side benefit of forcing atomic drivers using
these helpers to implement event handlign at least semi-correct. I'm
evil that way ;-)
- Ridiculously modular, as usual.
- The main tracking unit for a commit stays struct drm_atomic_state,
and the ownership rules for that are unchanged. Ownership still
gets transferred to the driver (and subsequently to the worker) on
successful commits. What is added is a small, per-crtc, refcounted
structure to track pending commits called struct drm_crtc_commit.
No actual state is attached to that though, it's purely for ordering
and waiting.
- Dependencies are implicitly handled by assuming that any CRTC part
of &drm_atomic_state is a dependency, and that the current commit
must wait for any commits to complete on those CRTC. This way
drivers can easily add more depencies using
drm_atomic_get_crtc_state(), which is very natural since in most
case a dependency exists iff there's some bit of state that needs to
be cross checked.
Removing depencies is not possible, drivers simply need to be
careful to not include every CRTC in a commit if that's not
necessary. Which is a good idea anyway, since that also avoids
ww_mutex lock contention.
- Queue depth > 1 sees some prep work in this patch by adding a stall
paramater to drm_atomic_helper_swap_states(). To be able to push
commits entirely free-standing and in a deeper queue through the
back-end the driver must not access any obj->state pointers. This
means we need to track the old state in drm_atomic_state (much
easier with the consolidated arrays), and pass them all explicitly
to driver backends (this will be serious amounts of churn).
Once that's done stall can be set to false in swap_states.
v2: Dont ask for flip_done signalling when the CRTC is off and stays
off: Drivers don't handle events in that case. Instead complete right
away. This way future commits don't need to have special-case logic,
but can keep blocking for the flip_done completion.
v3: Tons of fixes:
- Stall for preceeding commit for real, not the current one by
accident.
- Add WARN_ON in case drivers don't fire the drm event.
- Don't double-free drm events.
v4: Make legacy cursor not stall.
v5: Extend the helper hook to cover the entire commit tail. Some
drivers need special code for cleanup and vblank waiting, this makes
it a bit more useful. Inspired by the rockchip driver.
v6: Add WARN_ON to catch drivers who forget to send out the
drm event.
v7: Fixup the stalls in swap_state for real!!
v8:
- Fixup trailing whitespace, spotted by Maarten.
- Actually wait for flip_done in cleanup_done, like the comment says
we should do. Thanks a lot for Tomeu for helping with debugging this
on.
v9: Now with awesome kerneldoc!
v10: Split out drm_crtc_commit tracking infrastructure.
v:
- Add missing static (Gustavo).
- Split out the sync functions, only do the actual nonblocking
logic in this patch (Maarten).
Cc: Gustavo Padovan <gustavo.padovan@collabora.co.uk>
Tested-by: Tomeu Vizoso <tomeu.vizoso@collabora.com>
Cc: Maarten Lankhorst <maarten.lankhorst@linux.intel.com>
Cc: Tomeu Vizoso <tomeu.vizoso@gmail.com>
Cc: Daniel Stone <daniels@collabora.com>
Tested-by: Liviu Dudau <Liviu.Dudau@arm.com>
Reviewed-by: Maarten Lankhorst <maarten.lankhorst@linux.intel.com>
Testcase: igt/kms_flip/*
Testcase: igt/kms_cursor*
Testcase: igt/kms*plane*
Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>
Link: http://patchwork.freedesktop.org/patch/msgid/1465388359-8070-10-git-send-email-daniel.vetter@ffwll.ch
2016-06-08 12:19:02 +00:00
|
|
|
|
|
|
|
struct drm_mode_config_helper_funcs *helper_private;
|
2008-11-07 22:05:41 +00:00
|
|
|
};
|
|
|
|
|
2014-11-26 01:29:46 +00:00
|
|
|
/**
|
|
|
|
* drm_for_each_plane_mask - iterate over planes specified by bitmask
|
|
|
|
* @plane: the loop cursor
|
|
|
|
* @dev: the DRM device
|
|
|
|
* @plane_mask: bitmask of plane indices
|
|
|
|
*
|
|
|
|
* Iterate over all planes specified by bitmask.
|
|
|
|
*/
|
|
|
|
#define drm_for_each_plane_mask(plane, dev, plane_mask) \
|
|
|
|
list_for_each_entry((plane), &(dev)->mode_config.plane_list, head) \
|
drm: fix potential dangling else problems in for_each_ macros
We have serious dangling else bugs waiting to happen in our for_each_
style macros with ifs. Consider, for example,
#define drm_for_each_plane_mask(plane, dev, plane_mask) \
list_for_each_entry((plane), &(dev)->mode_config.plane_list, head) \
if ((plane_mask) & (1 << drm_plane_index(plane)))
If this is used in context:
if (condition)
drm_for_each_plane_mask(plane, dev, plane_mask);
else
foo();
foo() will be called for each plane *not* in plane_mask, if condition
holds, and not at all if condition doesn't hold.
Fix this by reversing the conditions in the macros, and adding an else
branch for the "for each" block, so that other if/else blocks can't
interfere. Provide a "for_each_if" helper macro to make it easier to get
this right.
Signed-off-by: Jani Nikula <jani.nikula@intel.com>
Link: http://patchwork.freedesktop.org/patch/msgid/1448392916-2281-1-git-send-email-jani.nikula@intel.com
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2015-11-24 19:21:55 +00:00
|
|
|
for_each_if ((plane_mask) & (1 << drm_plane_index(plane)))
|
2014-11-26 01:29:46 +00:00
|
|
|
|
2008-11-07 22:05:41 +00:00
|
|
|
#define obj_to_crtc(x) container_of(x, struct drm_crtc, base)
|
2011-11-14 22:51:27 +00:00
|
|
|
#define obj_to_plane(x) container_of(x, struct drm_plane, base)
|
2008-11-07 22:05:41 +00:00
|
|
|
|
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 14:19:31 +00:00
|
|
|
extern __printf(6, 7)
|
|
|
|
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, ...);
|
2008-11-07 22:05:41 +00:00
|
|
|
extern void drm_crtc_cleanup(struct drm_crtc *crtc);
|
2016-05-27 19:05:00 +00: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.
|
|
|
|
*/
|
|
|
|
static inline unsigned int drm_crtc_index(struct drm_crtc *crtc)
|
|
|
|
{
|
|
|
|
return crtc->index;
|
|
|
|
}
|
2014-01-02 21:27:33 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_crtc_mask - find the mask of a registered CRTC
|
|
|
|
* @crtc: CRTC to find mask for
|
|
|
|
*
|
|
|
|
* Given a registered CRTC, return the mask bit of that CRTC for an
|
|
|
|
* encoder's possible_crtcs field.
|
|
|
|
*/
|
|
|
|
static inline uint32_t drm_crtc_mask(struct drm_crtc *crtc)
|
|
|
|
{
|
|
|
|
return 1 << drm_crtc_index(crtc);
|
|
|
|
}
|
2008-11-07 22:05:41 +00:00
|
|
|
|
drm: Pass 'name' to drm_universal_plane_init()
Done with coccinelle for the most part. It choked on
msm/mdp/mdp5/mdp5_plane.c like so:
"BAD:!!!!! enum drm_plane_type type;"
No idea how to deal with that, so I just fixed that up
by hand.
Also 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_plane_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.
@@
typedef uint32_t;
identifier dev, plane, possible_crtcs, funcs, formats, format_count, type;
@@
int drm_universal_plane_init(struct drm_device *dev,
struct drm_plane *plane,
unsigned long possible_crtcs,
const struct drm_plane_funcs *funcs,
const uint32_t *formats,
unsigned int format_count,
enum drm_plane_type type
+ ,const char *name, int DOTDOTDOT
)
{ ... }
@@
identifier dev, plane, possible_crtcs, funcs, formats, format_count, type;
@@
int drm_universal_plane_init(struct drm_device *dev,
struct drm_plane *plane,
unsigned long possible_crtcs,
const struct drm_plane_funcs *funcs,
const uint32_t *formats,
unsigned int format_count,
enum drm_plane_type type
+ ,const char *name, int DOTDOTDOT
);
@@
expression E1, E2, E3, E4, E5, E6, E7;
@@
drm_universal_plane_init(E1, E2, E3, E4, E5, E6, E7
+ ,NULL
)
v2: Split crtc and plane changes apart
Pass NUL for no-name instead of ""
Leave drm_plane_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/1449670795-2853-1-git-send-email-ville.syrjala@linux.intel.com
2015-12-09 14:19:55 +00:00
|
|
|
extern __printf(8, 9)
|
|
|
|
int drm_universal_plane_init(struct drm_device *dev,
|
|
|
|
struct drm_plane *plane,
|
|
|
|
unsigned long possible_crtcs,
|
|
|
|
const struct drm_plane_funcs *funcs,
|
|
|
|
const uint32_t *formats,
|
|
|
|
unsigned int format_count,
|
|
|
|
enum drm_plane_type type,
|
|
|
|
const char *name, ...);
|
2011-11-14 22:51:27 +00:00
|
|
|
extern int drm_plane_init(struct drm_device *dev,
|
|
|
|
struct drm_plane *plane,
|
|
|
|
unsigned long possible_crtcs,
|
|
|
|
const struct drm_plane_funcs *funcs,
|
2015-08-12 14:54:28 +00:00
|
|
|
const uint32_t *formats, unsigned int format_count,
|
2014-04-01 22:22:36 +00:00
|
|
|
bool is_primary);
|
2011-11-14 22:51:27 +00:00
|
|
|
extern void drm_plane_cleanup(struct drm_plane *plane);
|
2016-05-27 19:05:00 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_plane_index - find the index of a registered plane
|
|
|
|
* @plane: plane to find index for
|
|
|
|
*
|
|
|
|
* Given a registered plane, return the index of that plane within a DRM
|
|
|
|
* device's list of planes.
|
|
|
|
*/
|
|
|
|
static inline unsigned int drm_plane_index(struct drm_plane *plane)
|
|
|
|
{
|
|
|
|
return plane->index;
|
|
|
|
}
|
2015-04-10 00:36:21 +00:00
|
|
|
extern struct drm_plane * drm_plane_from_index(struct drm_device *dev, int idx);
|
2013-06-03 13:10:40 +00:00
|
|
|
extern void drm_plane_force_disable(struct drm_plane *plane);
|
2014-12-01 23:40:09 +00:00
|
|
|
extern void drm_crtc_get_hv_timing(const struct drm_display_mode *mode,
|
|
|
|
int *hdisplay, int *vdisplay);
|
2016-06-08 16:47:27 +00:00
|
|
|
extern int drm_crtc_force_disable(struct drm_crtc *crtc);
|
|
|
|
extern int drm_crtc_force_disable_all(struct drm_device *dev);
|
2011-11-14 22:51:27 +00:00
|
|
|
|
2008-11-07 22:05:41 +00:00
|
|
|
extern void drm_mode_config_init(struct drm_device *dev);
|
2011-01-24 15:11:08 +00:00
|
|
|
extern void drm_mode_config_reset(struct drm_device *dev);
|
2008-11-07 22:05:41 +00:00
|
|
|
extern void drm_mode_config_cleanup(struct drm_device *dev);
|
2014-01-23 14:52:20 +00:00
|
|
|
|
2012-02-01 10:38:23 +00:00
|
|
|
extern int drm_mode_crtc_set_gamma_size(struct drm_crtc *crtc,
|
2008-11-07 22:05:41 +00:00
|
|
|
int gamma_size);
|
2014-05-30 15:37:03 +00:00
|
|
|
|
2012-12-11 12:47:23 +00:00
|
|
|
extern int drm_mode_set_config_internal(struct drm_mode_set *set);
|
2016-06-21 08:54:13 +00:00
|
|
|
|
2014-10-20 06:17:17 +00:00
|
|
|
extern struct drm_tile_group *drm_mode_create_tile_group(struct drm_device *dev,
|
|
|
|
char topology[8]);
|
|
|
|
extern struct drm_tile_group *drm_mode_get_tile_group(struct drm_device *dev,
|
|
|
|
char topology[8]);
|
|
|
|
extern void drm_mode_put_tile_group(struct drm_device *dev,
|
|
|
|
struct drm_tile_group *tg);
|
2011-02-07 02:16:14 +00:00
|
|
|
|
2014-08-20 13:45:00 +00:00
|
|
|
extern int drm_mode_plane_set_obj_prop(struct drm_plane *plane,
|
|
|
|
struct drm_property *property,
|
|
|
|
uint64_t value);
|
2011-11-29 20:02:54 +00:00
|
|
|
|
2014-07-08 05:01:53 +00:00
|
|
|
extern struct drm_property *drm_mode_create_rotation_property(struct drm_device *dev,
|
|
|
|
unsigned int supported_rotations);
|
2014-07-08 05:01:56 +00:00
|
|
|
extern unsigned int drm_rotation_simplify(unsigned int rotation,
|
|
|
|
unsigned int supported_rotations);
|
2016-06-07 12:09:14 +00:00
|
|
|
extern void drm_crtc_enable_color_mgmt(struct drm_crtc *crtc,
|
|
|
|
uint degamma_lut_size,
|
|
|
|
bool has_ctm,
|
|
|
|
uint gamma_lut_size);
|
2016-06-13 09:11:26 +00:00
|
|
|
|
|
|
|
int drm_plane_create_zpos_property(struct drm_plane *plane,
|
|
|
|
unsigned int zpos,
|
|
|
|
unsigned int min, unsigned int max);
|
|
|
|
|
|
|
|
int drm_plane_create_zpos_immutable_property(struct drm_plane *plane,
|
|
|
|
unsigned int zpos);
|
|
|
|
|
2012-08-15 12:59:49 +00:00
|
|
|
/* Helpers */
|
2013-10-05 20:36:52 +00:00
|
|
|
static inline struct drm_plane *drm_plane_find(struct drm_device *dev,
|
|
|
|
uint32_t id)
|
|
|
|
{
|
|
|
|
struct drm_mode_object *mo;
|
|
|
|
mo = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_PLANE);
|
|
|
|
return mo ? obj_to_plane(mo) : NULL;
|
|
|
|
}
|
|
|
|
|
2012-08-15 12:59:49 +00:00
|
|
|
static inline struct drm_crtc *drm_crtc_find(struct drm_device *dev,
|
|
|
|
uint32_t id)
|
|
|
|
{
|
|
|
|
struct drm_mode_object *mo;
|
|
|
|
mo = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_CRTC);
|
|
|
|
return mo ? obj_to_crtc(mo) : NULL;
|
|
|
|
}
|
|
|
|
|
2016-02-26 17:05:00 +00:00
|
|
|
/*
|
|
|
|
* Extract a degamma/gamma LUT value provided by user and round it to the
|
|
|
|
* precision supported by the hardware.
|
|
|
|
*/
|
|
|
|
static inline uint32_t drm_color_lut_extract(uint32_t user_input,
|
|
|
|
uint32_t bit_precision)
|
|
|
|
{
|
2016-03-22 14:10:33 +00:00
|
|
|
uint32_t val = user_input;
|
2016-02-26 17:05:00 +00:00
|
|
|
uint32_t max = 0xffff >> (16 - bit_precision);
|
|
|
|
|
2016-03-22 14:10:33 +00:00
|
|
|
/* Round only if we're not using full precision. */
|
|
|
|
if (bit_precision < 16) {
|
|
|
|
val += 1UL << (16 - bit_precision - 1);
|
|
|
|
val >>= 16 - bit_precision;
|
|
|
|
}
|
2016-02-26 17:05:00 +00:00
|
|
|
|
|
|
|
return clamp_val(val, 0, max);
|
|
|
|
}
|
|
|
|
|
2014-04-01 22:22:30 +00:00
|
|
|
/* Plane list iterator for legacy (overlay only) planes. */
|
2015-07-09 21:44:24 +00:00
|
|
|
#define drm_for_each_legacy_plane(plane, dev) \
|
|
|
|
list_for_each_entry(plane, &(dev)->mode_config.plane_list, head) \
|
drm: fix potential dangling else problems in for_each_ macros
We have serious dangling else bugs waiting to happen in our for_each_
style macros with ifs. Consider, for example,
#define drm_for_each_plane_mask(plane, dev, plane_mask) \
list_for_each_entry((plane), &(dev)->mode_config.plane_list, head) \
if ((plane_mask) & (1 << drm_plane_index(plane)))
If this is used in context:
if (condition)
drm_for_each_plane_mask(plane, dev, plane_mask);
else
foo();
foo() will be called for each plane *not* in plane_mask, if condition
holds, and not at all if condition doesn't hold.
Fix this by reversing the conditions in the macros, and adding an else
branch for the "for each" block, so that other if/else blocks can't
interfere. Provide a "for_each_if" helper macro to make it easier to get
this right.
Signed-off-by: Jani Nikula <jani.nikula@intel.com>
Link: http://patchwork.freedesktop.org/patch/msgid/1448392916-2281-1-git-send-email-jani.nikula@intel.com
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2015-11-24 19:21:55 +00:00
|
|
|
for_each_if (plane->type == DRM_PLANE_TYPE_OVERLAY)
|
2014-04-01 22:22:30 +00:00
|
|
|
|
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-09 21:44:25 +00:00
|
|
|
#define drm_for_each_plane(plane, dev) \
|
|
|
|
list_for_each_entry(plane, &(dev)->mode_config.plane_list, head)
|
|
|
|
|
|
|
|
#define drm_for_each_crtc(crtc, dev) \
|
|
|
|
list_for_each_entry(crtc, &(dev)->mode_config.crtc_list, head)
|
|
|
|
|
2015-07-09 21:44:28 +00:00
|
|
|
static inline void
|
|
|
|
assert_drm_connector_list_read_locked(struct drm_mode_config *mode_config)
|
|
|
|
{
|
2015-07-09 21:44:33 +00:00
|
|
|
/*
|
|
|
|
* The connector hotadd/remove code currently grabs both locks when
|
|
|
|
* updating lists. Hence readers need only hold either of them to be
|
|
|
|
* safe and the check amounts to
|
|
|
|
*
|
|
|
|
* WARN_ON(not_holding(A) && not_holding(B)).
|
|
|
|
*/
|
|
|
|
WARN_ON(!mutex_is_locked(&mode_config->mutex) &&
|
|
|
|
!drm_modeset_is_locked(&mode_config->connection_mutex));
|
2015-07-09 21:44:28 +00:00
|
|
|
}
|
|
|
|
|
2016-06-21 08:54:13 +00:00
|
|
|
/* drm_edid.c */
|
|
|
|
bool drm_probe_ddc(struct i2c_adapter *adapter);
|
|
|
|
struct edid *drm_get_edid(struct drm_connector *connector,
|
|
|
|
struct i2c_adapter *adapter);
|
|
|
|
struct edid *drm_get_edid_switcheroo(struct drm_connector *connector,
|
|
|
|
struct i2c_adapter *adapter);
|
|
|
|
struct edid *drm_edid_duplicate(const struct edid *edid);
|
|
|
|
int drm_add_edid_modes(struct drm_connector *connector, struct edid *edid);
|
|
|
|
|
|
|
|
u8 drm_match_cea_mode(const struct drm_display_mode *to_match);
|
|
|
|
enum hdmi_picture_aspect drm_get_cea_aspect_ratio(const u8 video_code);
|
|
|
|
bool drm_detect_hdmi_monitor(struct edid *edid);
|
|
|
|
bool drm_detect_monitor_audio(struct edid *edid);
|
|
|
|
bool drm_rgb_quant_range_selectable(struct edid *edid);
|
|
|
|
int drm_add_modes_noedid(struct drm_connector *connector,
|
|
|
|
int hdisplay, int vdisplay);
|
|
|
|
void drm_set_preferred_mode(struct drm_connector *connector,
|
|
|
|
int hpref, int vpref);
|
|
|
|
|
|
|
|
int drm_edid_header_is_valid(const u8 *raw_edid);
|
|
|
|
bool drm_edid_block_valid(u8 *raw_edid, int block, bool print_bad_edid,
|
|
|
|
bool *edid_corrupt);
|
|
|
|
bool drm_edid_is_valid(struct edid *edid);
|
|
|
|
void drm_edid_get_monitor_name(struct edid *edid, char *name,
|
|
|
|
int buflen);
|
|
|
|
struct drm_display_mode *drm_mode_find_dmt(struct drm_device *dev,
|
|
|
|
int hsize, int vsize, int fresh,
|
|
|
|
bool rb);
|
|
|
|
|
2008-11-07 22:05:41 +00:00
|
|
|
#endif /* __DRM_CRTC_H__ */
|