2008-11-08 06:05:41 +08: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 18:04:07 +08:00
|
|
|
#include <linux/hdmi.h>
|
2014-08-29 18:12:40 +08:00
|
|
|
#include <uapi/drm/drm_mode.h>
|
|
|
|
|
#include <uapi/drm/drm_fourcc.h>
|
2013-11-20 01:10:12 +08:00
|
|
|
#include <drm/drm_modeset_lock.h>
|
2011-11-15 06:51:28 +08:00
|
|
|
|
2008-11-08 06:05:41 +08:00
|
|
|
struct drm_device;
|
|
|
|
|
struct drm_mode_set;
|
|
|
|
|
struct drm_framebuffer;
|
2012-05-16 05:09:01 +08:00
|
|
|
struct drm_object_properties;
|
2012-11-21 22:00:47 +08:00
|
|
|
struct drm_file;
|
|
|
|
|
struct drm_clip_rect;
|
2014-06-15 18:07:12 +08:00
|
|
|
struct device_node;
|
2014-10-29 18:34:56 +08:00
|
|
|
struct fence;
|
2008-11-08 06:05:41 +08:00
|
|
|
|
|
|
|
|
#define DRM_MODE_OBJECT_CRTC 0xcccccccc
|
|
|
|
|
#define DRM_MODE_OBJECT_CONNECTOR 0xc0c0c0c0
|
|
|
|
|
#define DRM_MODE_OBJECT_ENCODER 0xe0e0e0e0
|
|
|
|
|
#define DRM_MODE_OBJECT_MODE 0xdededede
|
|
|
|
|
#define DRM_MODE_OBJECT_PROPERTY 0xb0b0b0b0
|
|
|
|
|
#define DRM_MODE_OBJECT_FB 0xfbfbfbfb
|
|
|
|
|
#define DRM_MODE_OBJECT_BLOB 0xbbbbbbbb
|
2011-11-15 06:51:27 +08:00
|
|
|
#define DRM_MODE_OBJECT_PLANE 0xeeeeeeee
|
2013-08-15 04:47:37 +08:00
|
|
|
#define DRM_MODE_OBJECT_BRIDGE 0xbdbdbdbd
|
2014-05-30 23:37:03 +08:00
|
|
|
#define DRM_MODE_OBJECT_ANY 0
|
2008-11-08 06:05:41 +08:00
|
|
|
|
|
|
|
|
struct drm_mode_object {
|
|
|
|
|
uint32_t id;
|
|
|
|
|
uint32_t type;
|
2012-05-16 05:09:01 +08:00
|
|
|
struct drm_object_properties *properties;
|
|
|
|
|
};
|
|
|
|
|
|
2012-06-12 22:27:01 +08:00
|
|
|
#define DRM_OBJECT_MAX_PROPERTY 24
|
2012-05-16 05:09:01 +08:00
|
|
|
struct drm_object_properties {
|
2014-12-19 05:01:50 +08:00
|
|
|
int count, atomic_count;
|
2014-12-17 07:05:30 +08:00
|
|
|
/* NOTE: if we ever start dynamically destroying properties (ie.
|
|
|
|
|
* not at drm_mode_config_cleanup() time), then we'd have to do
|
|
|
|
|
* a better job of detaching property from mode objects to avoid
|
|
|
|
|
* dangling property pointers:
|
|
|
|
|
*/
|
|
|
|
|
struct drm_property *properties[DRM_OBJECT_MAX_PROPERTY];
|
2014-12-17 07:05:31 +08:00
|
|
|
/* do not read/write values directly, but use drm_object_property_get_value()
|
|
|
|
|
* and drm_object_property_set_value():
|
|
|
|
|
*/
|
2012-05-16 05:09:01 +08:00
|
|
|
uint64_t values[DRM_OBJECT_MAX_PROPERTY];
|
2008-11-08 06:05:41 +08:00
|
|
|
};
|
|
|
|
|
|
2012-09-13 11:22:31 +08: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);
|
|
|
|
|
}
|
|
|
|
|
|
2014-07-08 13:01:51 +08:00
|
|
|
/* rotation property bits */
|
|
|
|
|
#define DRM_ROTATE_0 0
|
|
|
|
|
#define DRM_ROTATE_90 1
|
|
|
|
|
#define DRM_ROTATE_180 2
|
|
|
|
|
#define DRM_ROTATE_270 3
|
|
|
|
|
#define DRM_REFLECT_X 4
|
|
|
|
|
#define DRM_REFLECT_Y 5
|
|
|
|
|
|
2014-01-23 22:52:20 +08:00
|
|
|
enum drm_connector_force {
|
|
|
|
|
DRM_FORCE_UNSPECIFIED,
|
|
|
|
|
DRM_FORCE_OFF,
|
|
|
|
|
DRM_FORCE_ON, /* force on analog part normally */
|
|
|
|
|
DRM_FORCE_ON_DIGITAL, /* for DVI-I use digital connector */
|
2008-11-08 06:05:41 +08:00
|
|
|
};
|
|
|
|
|
|
2014-01-23 22:52:20 +08:00
|
|
|
#include <drm/drm_modes.h>
|
2013-09-25 23:45:21 +08:00
|
|
|
|
2008-11-08 06:05:41 +08:00
|
|
|
enum drm_connector_status {
|
|
|
|
|
connector_status_connected = 1,
|
|
|
|
|
connector_status_disconnected = 2,
|
|
|
|
|
connector_status_unknown = 3,
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
enum subpixel_order {
|
|
|
|
|
SubPixelUnknown = 0,
|
|
|
|
|
SubPixelHorizontalRGB,
|
|
|
|
|
SubPixelHorizontalBGR,
|
|
|
|
|
SubPixelVerticalRGB,
|
|
|
|
|
SubPixelVerticalBGR,
|
|
|
|
|
SubPixelNone,
|
|
|
|
|
};
|
|
|
|
|
|
2011-04-16 04:48:57 +08:00
|
|
|
#define DRM_COLOR_FORMAT_RGB444 (1<<0)
|
|
|
|
|
#define DRM_COLOR_FORMAT_YCRCB444 (1<<1)
|
|
|
|
|
#define DRM_COLOR_FORMAT_YCRCB422 (1<<2)
|
2008-11-08 06:05:41 +08:00
|
|
|
/*
|
|
|
|
|
* Describes a given display (e.g. CRT or flat panel) and its limitations.
|
|
|
|
|
*/
|
|
|
|
|
struct drm_display_info {
|
|
|
|
|
char name[DRM_DISPLAY_INFO_LEN];
|
2010-08-04 02:38:16 +08:00
|
|
|
|
2008-11-08 06:05:41 +08:00
|
|
|
/* Physical size */
|
|
|
|
|
unsigned int width_mm;
|
|
|
|
|
unsigned int height_mm;
|
|
|
|
|
|
|
|
|
|
/* Clock limits FIXME: storage format */
|
|
|
|
|
unsigned int min_vfreq, max_vfreq;
|
|
|
|
|
unsigned int min_hfreq, max_hfreq;
|
|
|
|
|
unsigned int pixel_clock;
|
2011-04-16 03:49:23 +08:00
|
|
|
unsigned int bpc;
|
2008-11-08 06:05:41 +08:00
|
|
|
|
|
|
|
|
enum subpixel_order subpixel_order;
|
2011-04-16 04:48:57 +08:00
|
|
|
u32 color_formats;
|
2008-11-08 06:05:41 +08:00
|
|
|
|
2014-06-05 21:52:10 +08:00
|
|
|
/* Mask of supported hdmi deep color modes */
|
|
|
|
|
u8 edid_hdmi_dc_modes;
|
|
|
|
|
|
2011-08-04 00:22:54 +08:00
|
|
|
u8 cea_rev;
|
2008-11-08 06:05:41 +08:00
|
|
|
};
|
|
|
|
|
|
2014-10-20 14:17:17 +08: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-08 06:05:41 +08:00
|
|
|
struct drm_framebuffer_funcs {
|
2012-09-06 05:48:38 +08:00
|
|
|
/* note: use drm_framebuffer_remove() */
|
2008-11-08 06:05:41 +08:00
|
|
|
void (*destroy)(struct drm_framebuffer *framebuffer);
|
|
|
|
|
int (*create_handle)(struct drm_framebuffer *fb,
|
|
|
|
|
struct drm_file *file_priv,
|
|
|
|
|
unsigned int *handle);
|
2014-10-27 23:54:27 +08:00
|
|
|
/*
|
|
|
|
|
* Optional callback for the dirty fb ioctl.
|
2009-12-04 07:25:47 +08:00
|
|
|
*
|
|
|
|
|
* Userspace can notify the driver via this callback
|
|
|
|
|
* that a area of the framebuffer has changed and should
|
|
|
|
|
* be flushed to the display hardware.
|
|
|
|
|
*
|
|
|
|
|
* See documentation in drm_mode.h for the struct
|
|
|
|
|
* drm_mode_fb_dirty_cmd for more information as all
|
|
|
|
|
* the semantics and arguments have a one to one mapping
|
|
|
|
|
* on this function.
|
|
|
|
|
*/
|
2010-10-05 18:43:02 +08:00
|
|
|
int (*dirty)(struct drm_framebuffer *framebuffer,
|
|
|
|
|
struct drm_file *file_priv, unsigned flags,
|
2009-12-04 07:25:47 +08:00
|
|
|
unsigned color, struct drm_clip_rect *clips,
|
|
|
|
|
unsigned num_clips);
|
2008-11-08 06:05:41 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct drm_framebuffer {
|
|
|
|
|
struct drm_device *dev;
|
2012-09-06 05:48:38 +08:00
|
|
|
/*
|
|
|
|
|
* Note that the fb is refcounted for the benefit of driver internals,
|
|
|
|
|
* for example some hw, disabling a CRTC/plane is asynchronous, and
|
|
|
|
|
* scanout does not actually complete until the next vblank. So some
|
|
|
|
|
* cleanup (like releasing the reference(s) on the backing GEM bo(s))
|
|
|
|
|
* should be deferred. In cases like this, the driver would like to
|
|
|
|
|
* hold a ref to the fb even though it has already been removed from
|
|
|
|
|
* userspace perspective.
|
|
|
|
|
*/
|
|
|
|
|
struct kref refcount;
|
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-11 04:19:18 +08:00
|
|
|
/*
|
|
|
|
|
* Place on the dev->mode_config.fb_list, access protected by
|
|
|
|
|
* dev->mode_config.fb_lock.
|
|
|
|
|
*/
|
2008-11-08 06:05:41 +08:00
|
|
|
struct list_head head;
|
|
|
|
|
struct drm_mode_object base;
|
|
|
|
|
const struct drm_framebuffer_funcs *funcs;
|
2011-12-20 06:06:49 +08:00
|
|
|
unsigned int pitches[4];
|
|
|
|
|
unsigned int offsets[4];
|
2008-11-08 06:05:41 +08:00
|
|
|
unsigned int width;
|
|
|
|
|
unsigned int height;
|
|
|
|
|
/* depth can be 15 or 16 */
|
|
|
|
|
unsigned int depth;
|
|
|
|
|
int bits_per_pixel;
|
|
|
|
|
int flags;
|
2011-11-15 06:51:28 +08:00
|
|
|
uint32_t pixel_format; /* fourcc format */
|
2008-11-08 06:05:41 +08:00
|
|
|
struct list_head filp_head;
|
2009-08-28 13:46:53 +08:00
|
|
|
/* if you are using the helper */
|
|
|
|
|
void *helper_private;
|
2008-11-08 06:05:41 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct drm_property_blob {
|
|
|
|
|
struct drm_mode_object base;
|
|
|
|
|
struct list_head head;
|
2014-05-13 17:36:13 +08:00
|
|
|
size_t length;
|
2012-03-13 18:35:49 +08:00
|
|
|
unsigned char data[];
|
2008-11-08 06:05:41 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct drm_property_enum {
|
|
|
|
|
uint64_t value;
|
|
|
|
|
struct list_head head;
|
|
|
|
|
char name[DRM_PROP_NAME_LEN];
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct drm_property {
|
|
|
|
|
struct list_head head;
|
|
|
|
|
struct drm_mode_object base;
|
|
|
|
|
uint32_t flags;
|
|
|
|
|
char name[DRM_PROP_NAME_LEN];
|
|
|
|
|
uint32_t num_values;
|
|
|
|
|
uint64_t *values;
|
2014-05-30 23:37:03 +08:00
|
|
|
struct drm_device *dev;
|
2008-11-08 06:05:41 +08:00
|
|
|
|
2014-11-20 01:38:10 +08:00
|
|
|
struct list_head enum_list;
|
2008-11-08 06:05:41 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct drm_crtc;
|
|
|
|
|
struct drm_connector;
|
|
|
|
|
struct drm_encoder;
|
2009-11-18 01:43:55 +08:00
|
|
|
struct drm_pending_vblank_event;
|
2011-11-15 06:51:27 +08:00
|
|
|
struct drm_plane;
|
2013-08-15 04:47:37 +08:00
|
|
|
struct drm_bridge;
|
2014-10-28 03:28:44 +08:00
|
|
|
struct drm_atomic_state;
|
|
|
|
|
|
|
|
|
|
/**
|
2014-07-26 03:30:38 +08:00
|
|
|
* struct drm_crtc_state - mutable CRTC state
|
2014-11-27 22:49:39 +08:00
|
|
|
* @crtc: backpointer to the CRTC
|
2014-10-28 03:28:44 +08:00
|
|
|
* @enable: whether the CRTC should be enabled, gates all other state
|
2014-11-26 23:57:41 +08:00
|
|
|
* @active: whether the CRTC is actively displaying (used for DPMS)
|
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 23:50:47 +08:00
|
|
|
* @mode_changed: for use by helpers and drivers when computing state updates
|
2014-11-22 04:28:31 +08:00
|
|
|
* @plane_mask: bitmask of (1 << drm_plane_index(plane)) of attached planes
|
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 23:50:47 +08: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-11-05 07:14:14 +08:00
|
|
|
* @planes_changed: for use by helpers and drivers when computing state updates
|
2014-10-29 18:13:47 +08:00
|
|
|
* @adjusted_mode: for use by helpers and drivers to compute adjusted mode timings
|
2014-10-28 03:28:44 +08:00
|
|
|
* @mode: current mode timings
|
|
|
|
|
* @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 23:57:41 +08: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-28 03:28:44 +08:00
|
|
|
*/
|
|
|
|
|
struct drm_crtc_state {
|
2014-11-27 22:49:39 +08:00
|
|
|
struct drm_crtc *crtc;
|
|
|
|
|
|
2014-07-26 03:30:38 +08:00
|
|
|
bool enable;
|
2014-11-26 23:57:41 +08:00
|
|
|
bool active;
|
2014-10-28 03:28:44 +08:00
|
|
|
|
2014-11-05 07:14:14 +08: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 23:50:47 +08:00
|
|
|
bool mode_changed : 1;
|
|
|
|
|
|
2014-11-22 04:28:31 +08: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;
|
|
|
|
|
|
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 23:50:47 +08:00
|
|
|
/* last_vblank_count: for vblank waits before cleanup */
|
|
|
|
|
u32 last_vblank_count;
|
2014-11-05 07:14:14 +08:00
|
|
|
|
2014-10-29 18:13:47 +08:00
|
|
|
/* adjusted_mode: for use by helpers and drivers */
|
|
|
|
|
struct drm_display_mode adjusted_mode;
|
|
|
|
|
|
2014-10-28 03:28:44 +08:00
|
|
|
struct drm_display_mode mode;
|
|
|
|
|
|
|
|
|
|
struct drm_pending_vblank_event *event;
|
|
|
|
|
|
|
|
|
|
struct drm_atomic_state *state;
|
|
|
|
|
};
|
2008-11-08 06:05:41 +08:00
|
|
|
|
|
|
|
|
/**
|
2014-10-27 23:54:27 +08:00
|
|
|
* struct drm_crtc_funcs - control CRTCs for a given device
|
2008-11-08 06:05:41 +08:00
|
|
|
* @save: save CRTC state
|
2012-05-17 19:27:20 +08:00
|
|
|
* @restore: restore CRTC state
|
2013-04-05 23:28:32 +08:00
|
|
|
* @reset: reset CRTC after state has been invalidated (e.g. resume)
|
2012-05-17 19:27:20 +08:00
|
|
|
* @cursor_set: setup the cursor
|
2014-10-28 03:19:38 +08:00
|
|
|
* @cursor_set2: setup the cursor with hotspot, superseeds @cursor_set if set
|
2012-05-17 19:27:20 +08:00
|
|
|
* @cursor_move: move the cursor
|
2008-11-08 06:05:41 +08:00
|
|
|
* @gamma_set: specify color ramp for CRTC
|
2012-05-16 05:09:05 +08:00
|
|
|
* @destroy: deinit and free object
|
|
|
|
|
* @set_property: called when a property is changed
|
2012-05-17 19:27:20 +08:00
|
|
|
* @set_config: apply a new CRTC configuration
|
|
|
|
|
* @page_flip: initiate a page flip
|
2014-10-28 03:28:44 +08:00
|
|
|
* @atomic_duplicate_state: duplicate the atomic state for this CRTC
|
|
|
|
|
* @atomic_destroy_state: destroy an atomic state for this CRTC
|
|
|
|
|
* @atomic_set_property: set a property on an atomic state for this CRTC
|
2014-12-19 05:01:46 +08:00
|
|
|
* (do not call directly, use drm_atomic_crtc_set_property())
|
2014-12-19 05:01:47 +08:00
|
|
|
* @atomic_get_property: get a property on an atomic state for this CRTC
|
|
|
|
|
* (do not call directly, use drm_atomic_crtc_get_property())
|
2008-11-08 06:05:41 +08: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 {
|
|
|
|
|
/* Save CRTC state */
|
|
|
|
|
void (*save)(struct drm_crtc *crtc); /* suspend? */
|
|
|
|
|
/* Restore CRTC state */
|
|
|
|
|
void (*restore)(struct drm_crtc *crtc); /* resume? */
|
2011-01-24 23:11:08 +08:00
|
|
|
/* Reset CRTC state */
|
|
|
|
|
void (*reset)(struct drm_crtc *crtc);
|
2008-11-08 06:05:41 +08:00
|
|
|
|
|
|
|
|
/* cursor controls */
|
|
|
|
|
int (*cursor_set)(struct drm_crtc *crtc, struct drm_file *file_priv,
|
|
|
|
|
uint32_t handle, uint32_t width, uint32_t height);
|
2013-06-20 09:48:52 +08: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);
|
2008-11-08 06:05:41 +08:00
|
|
|
int (*cursor_move)(struct drm_crtc *crtc, int x, int y);
|
|
|
|
|
|
|
|
|
|
/* Set gamma on the CRTC */
|
|
|
|
|
void (*gamma_set)(struct drm_crtc *crtc, u16 *r, u16 *g, u16 *b,
|
2010-08-03 08:33:19 +08:00
|
|
|
uint32_t start, uint32_t size);
|
2008-11-08 06:05:41 +08:00
|
|
|
/* Object destroy routine */
|
|
|
|
|
void (*destroy)(struct drm_crtc *crtc);
|
|
|
|
|
|
|
|
|
|
int (*set_config)(struct drm_mode_set *set);
|
2009-11-18 01:43:55 +08:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Flip to the given framebuffer. This implements the page
|
2011-03-31 09:57:33 +08:00
|
|
|
* flip ioctl described in drm_mode.h, specifically, the
|
2009-11-18 01:43:55 +08:00
|
|
|
* implementation must return immediately and block all
|
|
|
|
|
* rendering to the current fb until the flip has completed.
|
|
|
|
|
* If userspace set the event flag in the ioctl, the event
|
|
|
|
|
* argument will point to an event to send back when the flip
|
|
|
|
|
* completes, otherwise it will be NULL.
|
|
|
|
|
*/
|
|
|
|
|
int (*page_flip)(struct drm_crtc *crtc,
|
|
|
|
|
struct drm_framebuffer *fb,
|
2013-07-23 09:49:58 +08:00
|
|
|
struct drm_pending_vblank_event *event,
|
|
|
|
|
uint32_t flags);
|
2012-05-16 05:09:05 +08:00
|
|
|
|
|
|
|
|
int (*set_property)(struct drm_crtc *crtc,
|
|
|
|
|
struct drm_property *property, uint64_t val);
|
2014-10-28 03:28:44 +08:00
|
|
|
|
|
|
|
|
/* atomic update handling */
|
|
|
|
|
struct drm_crtc_state *(*atomic_duplicate_state)(struct drm_crtc *crtc);
|
|
|
|
|
void (*atomic_destroy_state)(struct drm_crtc *crtc,
|
2014-07-26 03:30:38 +08:00
|
|
|
struct drm_crtc_state *state);
|
2014-10-28 03:28:44 +08:00
|
|
|
int (*atomic_set_property)(struct drm_crtc *crtc,
|
|
|
|
|
struct drm_crtc_state *state,
|
|
|
|
|
struct drm_property *property,
|
|
|
|
|
uint64_t val);
|
2014-12-19 05:01:47 +08:00
|
|
|
int (*atomic_get_property)(struct drm_crtc *crtc,
|
|
|
|
|
const struct drm_crtc_state *state,
|
|
|
|
|
struct drm_property *property,
|
|
|
|
|
uint64_t *val);
|
2008-11-08 06:05:41 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/**
|
2014-10-27 23:54:27 +08:00
|
|
|
* struct drm_crtc - central CRTC control structure
|
2011-11-08 04:03:14 +08:00
|
|
|
* @dev: parent DRM device
|
2014-10-28 03:19:38 +08:00
|
|
|
* @port: OF node used by drm_of_find_possible_crtcs()
|
2011-11-08 04:03:14 +08:00
|
|
|
* @head: list management
|
2013-11-20 01:10:12 +08:00
|
|
|
* @mutex: per-CRTC locking
|
2011-11-08 04:03:14 +08:00
|
|
|
* @base: base KMS object for ID tracking etc.
|
2014-04-02 06:22:38 +08:00
|
|
|
* @primary: primary plane for this CRTC
|
|
|
|
|
* @cursor: cursor plane for this CRTC
|
2014-10-28 03:19:38 +08: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-08 06:05:41 +08:00
|
|
|
* @enabled: is this CRTC enabled?
|
2011-11-08 04:03:14 +08:00
|
|
|
* @mode: current mode timings
|
|
|
|
|
* @hwmode: mode timings as programmed to hw regs
|
2012-09-05 00:35:56 +08:00
|
|
|
* @invert_dimensions: for purposes of error checking crtc vs fb sizes,
|
|
|
|
|
* invert the width/height of the crtc. This is used if the driver
|
|
|
|
|
* is performing 90 or 270 degree rotated scanout
|
2008-11-08 06:05:41 +08:00
|
|
|
* @x: x position on screen
|
|
|
|
|
* @y: y position on screen
|
|
|
|
|
* @funcs: CRTC control functions
|
2011-11-08 04:03:14 +08:00
|
|
|
* @gamma_size: size of gamma ramp
|
|
|
|
|
* @gamma_store: gamma ramp values
|
|
|
|
|
* @framedur_ns: precise frame timing
|
2014-10-28 03:19:38 +08:00
|
|
|
* @linedur_ns: precise line timing
|
2011-11-08 04:03:14 +08:00
|
|
|
* @pixeldur_ns: precise pixel timing
|
|
|
|
|
* @helper_private: mid-layer private data
|
2012-05-16 05:09:05 +08:00
|
|
|
* @properties: property tracking for this CRTC
|
2014-10-28 03:28:44 +08:00
|
|
|
* @state: current atomic state for this CRTC
|
2014-10-28 03:19:38 +08:00
|
|
|
* @acquire_ctx: per-CRTC implicit acquire context used by atomic drivers for
|
|
|
|
|
* legacy ioctls
|
2008-11-08 06:05:41 +08: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 18:07:12 +08:00
|
|
|
struct device_node *port;
|
2008-11-08 06:05:41 +08:00
|
|
|
struct list_head head;
|
|
|
|
|
|
2014-10-27 23:54:27 +08:00
|
|
|
/*
|
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 09:18:25 +08:00
|
|
|
* crtc mutex
|
|
|
|
|
*
|
|
|
|
|
* This provides a read lock for the overall crtc state (mode, dpms
|
|
|
|
|
* state, ...) and a write lock for everything which can be update
|
|
|
|
|
* without a full modeset (fb, cursor data, ...)
|
|
|
|
|
*/
|
2013-11-20 01:10:12 +08: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 09:18:25 +08:00
|
|
|
|
2008-11-08 06:05:41 +08:00
|
|
|
struct drm_mode_object base;
|
|
|
|
|
|
2014-04-02 06:22:38 +08:00
|
|
|
/* primary and cursor planes for CRTC */
|
|
|
|
|
struct drm_plane *primary;
|
|
|
|
|
struct drm_plane *cursor;
|
|
|
|
|
|
2014-06-10 23:28:10 +08:00
|
|
|
/* position of cursor plane on crtc */
|
|
|
|
|
int cursor_x;
|
|
|
|
|
int cursor_y;
|
|
|
|
|
|
2008-11-08 06:05:41 +08: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 10:20:23 +08:00
|
|
|
/* Requested mode from modesetting. */
|
2008-11-08 06:05:41 +08: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 10:20:23 +08:00
|
|
|
/* Programmed mode in hw, after adjustments for encoders,
|
|
|
|
|
* crtc, panel scaling etc. Needed for timestamping etc.
|
|
|
|
|
*/
|
|
|
|
|
struct drm_display_mode hwmode;
|
|
|
|
|
|
2012-09-05 00:35:56 +08:00
|
|
|
bool invert_dimensions;
|
|
|
|
|
|
2008-11-08 06:05:41 +08:00
|
|
|
int x, y;
|
|
|
|
|
const struct drm_crtc_funcs *funcs;
|
|
|
|
|
|
|
|
|
|
/* CRTC gamma size for reporting to userspace */
|
|
|
|
|
uint32_t gamma_size;
|
|
|
|
|
uint16_t *gamma_store;
|
|
|
|
|
|
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 10:20:23 +08:00
|
|
|
/* Constants needed for precise vblank and swap timestamping. */
|
2013-10-26 22:38:52 +08:00
|
|
|
int framedur_ns, linedur_ns, pixeldur_ns;
|
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 10:20:23 +08:00
|
|
|
|
2008-11-08 06:05:41 +08:00
|
|
|
/* if you are using the helper */
|
|
|
|
|
void *helper_private;
|
2012-05-16 05:09:05 +08:00
|
|
|
|
|
|
|
|
struct drm_object_properties properties;
|
2014-07-26 00:07:40 +08:00
|
|
|
|
2014-10-28 03:28:44 +08:00
|
|
|
struct drm_crtc_state *state;
|
|
|
|
|
|
2014-07-26 00:07:40 +08:00
|
|
|
/*
|
|
|
|
|
* For legacy crtc ioctls so that atomic drivers can get at the locking
|
|
|
|
|
* acquire context.
|
|
|
|
|
*/
|
|
|
|
|
struct drm_modeset_acquire_ctx *acquire_ctx;
|
2008-11-08 06:05:41 +08:00
|
|
|
};
|
|
|
|
|
|
2014-10-28 03:28:44 +08:00
|
|
|
/**
|
|
|
|
|
* struct drm_connector_state - mutable connector state
|
2014-11-27 22:49:39 +08:00
|
|
|
* @connector: backpointer to the connector
|
2014-07-26 03:30:38 +08:00
|
|
|
* @crtc: CRTC to connect connector to, NULL if disabled
|
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 23:50:47 +08:00
|
|
|
* @best_encoder: can be used by helpers and drivers to select the encoder
|
2014-10-28 03:28:44 +08:00
|
|
|
* @state: backpointer to global drm_atomic_state
|
|
|
|
|
*/
|
|
|
|
|
struct drm_connector_state {
|
2014-11-27 22:49:39 +08:00
|
|
|
struct drm_connector *connector;
|
|
|
|
|
|
2014-11-22 04:28:31 +08:00
|
|
|
struct drm_crtc *crtc; /* do not write directly, use drm_atomic_set_crtc_for_connector() */
|
2014-10-28 03:28:44 +08: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 23:50:47 +08:00
|
|
|
struct drm_encoder *best_encoder;
|
|
|
|
|
|
2014-10-28 03:28:44 +08:00
|
|
|
struct drm_atomic_state *state;
|
|
|
|
|
};
|
2008-11-08 06:05:41 +08:00
|
|
|
|
|
|
|
|
/**
|
2014-10-27 23:54:27 +08:00
|
|
|
* struct drm_connector_funcs - control connectors on a given device
|
2014-12-17 23:41:40 +08:00
|
|
|
* @dpms: set power state
|
2008-11-08 06:05:41 +08:00
|
|
|
* @save: save connector state
|
|
|
|
|
* @restore: restore connector state
|
2013-03-07 23:42:25 +08:00
|
|
|
* @reset: reset connector after state has been invalidated (e.g. resume)
|
2008-11-08 06:05:41 +08:00
|
|
|
* @detect: is this connector active?
|
2012-05-17 19:27:20 +08:00
|
|
|
* @fill_modes: fill mode list for this connector
|
2013-03-07 23:42:25 +08:00
|
|
|
* @set_property: property for this connector may need an update
|
2008-11-08 06:05:41 +08:00
|
|
|
* @destroy: make object go away
|
2013-03-07 23:42:25 +08:00
|
|
|
* @force: notify the driver that the connector is forced on
|
2014-10-28 03:28:44 +08:00
|
|
|
* @atomic_duplicate_state: duplicate the atomic state for this connector
|
|
|
|
|
* @atomic_destroy_state: destroy an atomic state for this connector
|
|
|
|
|
* @atomic_set_property: set a property on an atomic state for this connector
|
2014-12-19 05:01:46 +08:00
|
|
|
* (do not call directly, use drm_atomic_connector_set_property())
|
2014-12-19 05:01:47 +08:00
|
|
|
* @atomic_get_property: get a property on an atomic state for this connector
|
|
|
|
|
* (do not call directly, use drm_atomic_connector_get_property())
|
2014-10-28 03:28:44 +08:00
|
|
|
*
|
2008-11-08 06:05:41 +08:00
|
|
|
* Each CRTC may have one or more connectors attached to it. The functions
|
|
|
|
|
* below allow the core DRM code to control connectors, enumerate available modes,
|
|
|
|
|
* etc.
|
|
|
|
|
*/
|
|
|
|
|
struct drm_connector_funcs {
|
|
|
|
|
void (*dpms)(struct drm_connector *connector, int mode);
|
|
|
|
|
void (*save)(struct drm_connector *connector);
|
|
|
|
|
void (*restore)(struct drm_connector *connector);
|
2011-01-24 23:11:08 +08:00
|
|
|
void (*reset)(struct drm_connector *connector);
|
2010-09-14 18:07:23 +08:00
|
|
|
|
|
|
|
|
/* Check to see if anything is attached to the connector.
|
|
|
|
|
* @force is set to false whilst polling, true when checking the
|
|
|
|
|
* connector due to user request. @force can be used by the driver
|
|
|
|
|
* to avoid expensive, destructive operations during automated
|
|
|
|
|
* probing.
|
|
|
|
|
*/
|
2010-09-10 06:51:02 +08:00
|
|
|
enum drm_connector_status (*detect)(struct drm_connector *connector,
|
2010-09-14 18:07:23 +08:00
|
|
|
bool force);
|
drm: initial KMS config fixes
When mode setting is first initialized, the driver will call into
drm_helper_initial_config() to set up an initial output and framebuffer
configuration. This routine is responsible for probing the available
connectors, encoders, and crtcs, looking for modes and putting together
something reasonable (where reasonable is defined as "allows kernel
messages to be visible on as many displays as possible").
However, the code was a bit too aggressive in setting default modes when
none were found on a given connector. Even if some connectors had modes,
any connectors found lacking modes would have the default 800x600 mode added
to their mode list, which in some cases could cause problems later down the
line. In my case, the LVDS was perfectly available, but the initial config
code added 800x600 modes to both of the detected but unavailable HDMI
connectors (which are on my non-existent docking station). This ended up
preventing later code from setting a mode on my LVDS, which is bad.
This patch fixes that behavior by making the initial config code walk
through the connectors first, counting the available modes, before it decides
to add any default modes to a possibly connected output. It also fixes the
logic in drm_target_preferred() that was causing zeroed out modes to be set
as the preferred mode for a given connector, even if no modes were available.
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
Signed-off-by: Eric Anholt <eric@anholt.net>
Signed-off-by: Dave Airlie <airlied@linux.ie>
2009-01-13 04:05:32 +08:00
|
|
|
int (*fill_modes)(struct drm_connector *connector, uint32_t max_width, uint32_t max_height);
|
2008-11-08 06:05:41 +08:00
|
|
|
int (*set_property)(struct drm_connector *connector, struct drm_property *property,
|
|
|
|
|
uint64_t val);
|
|
|
|
|
void (*destroy)(struct drm_connector *connector);
|
drm/kms: start adding command line interface using fb.
[note this requires an fb patch posted to linux-fbdev-devel already]
This uses the normal video= command line option to control the kms
output setup at boot time. It is used to override the autodetection
done by kms.
video= normally takes a framebuffer as the first parameter, in kms
it will take a connector name, DVI-I-1, or LVDS-1 etc. If no output
connector is specified the mode string will apply to all connectors.
The mode specification used will match down the probed modes, and if
no mode is found it will add a CVT mode that matches.
video=1024x768 - all connectors match a 1024x768 mode or add a CVT on
video=VGA-1:1024x768, VGA-1 connector gets mode only.
The same strings as used in current fb modedb.c are used, except I've
added three more letters, e, D, d, e = enable, D = enable Digital,
d = disable, which allow a connector to be forced into a certain state.
Signed-off-by: Dave Airlie <airlied@redhat.com>
2009-09-23 12:44:08 +08:00
|
|
|
void (*force)(struct drm_connector *connector);
|
2014-10-28 03:28:44 +08:00
|
|
|
|
|
|
|
|
/* atomic update handling */
|
|
|
|
|
struct drm_connector_state *(*atomic_duplicate_state)(struct drm_connector *connector);
|
|
|
|
|
void (*atomic_destroy_state)(struct drm_connector *connector,
|
2014-07-26 03:30:38 +08:00
|
|
|
struct drm_connector_state *state);
|
2014-10-28 03:28:44 +08:00
|
|
|
int (*atomic_set_property)(struct drm_connector *connector,
|
|
|
|
|
struct drm_connector_state *state,
|
|
|
|
|
struct drm_property *property,
|
|
|
|
|
uint64_t val);
|
2014-12-19 05:01:47 +08:00
|
|
|
int (*atomic_get_property)(struct drm_connector *connector,
|
|
|
|
|
const struct drm_connector_state *state,
|
|
|
|
|
struct drm_property *property,
|
|
|
|
|
uint64_t *val);
|
2008-11-08 06:05:41 +08:00
|
|
|
};
|
|
|
|
|
|
2011-11-08 04:03:16 +08:00
|
|
|
/**
|
2014-10-27 23:54:27 +08:00
|
|
|
* struct drm_encoder_funcs - encoder controls
|
2011-11-08 04:03:16 +08:00
|
|
|
* @reset: reset state (e.g. at init or resume time)
|
|
|
|
|
* @destroy: cleanup and free associated data
|
|
|
|
|
*
|
|
|
|
|
* Encoders sit between CRTCs and connectors.
|
|
|
|
|
*/
|
2008-11-08 06:05:41 +08:00
|
|
|
struct drm_encoder_funcs {
|
2011-01-24 23:11:08 +08:00
|
|
|
void (*reset)(struct drm_encoder *encoder);
|
2008-11-08 06:05:41 +08:00
|
|
|
void (*destroy)(struct drm_encoder *encoder);
|
|
|
|
|
};
|
|
|
|
|
|
2012-01-12 14:00:57 +08:00
|
|
|
#define DRM_CONNECTOR_MAX_ENCODER 3
|
2008-11-08 06:05:41 +08:00
|
|
|
|
|
|
|
|
/**
|
2014-10-27 23:54:27 +08:00
|
|
|
* struct drm_encoder - central DRM encoder structure
|
2011-11-08 04:03:17 +08:00
|
|
|
* @dev: parent DRM device
|
|
|
|
|
* @head: list management
|
|
|
|
|
* @base: base KMS object
|
2014-05-14 21:58:20 +08:00
|
|
|
* @name: encoder name
|
2011-11-08 04:03:17 +08:00
|
|
|
* @encoder_type: one of the %DRM_MODE_ENCODER_<foo> types in drm_mode.h
|
|
|
|
|
* @possible_crtcs: bitmask of potential CRTC bindings
|
|
|
|
|
* @possible_clones: bitmask of potential sibling encoders for cloning
|
|
|
|
|
* @crtc: currently bound CRTC
|
2013-08-15 04:47:37 +08:00
|
|
|
* @bridge: bridge associated to the encoder
|
2011-11-08 04:03:17 +08:00
|
|
|
* @funcs: control functions
|
|
|
|
|
* @helper_private: mid-layer private data
|
|
|
|
|
*
|
|
|
|
|
* CRTCs drive pixels to encoders, which convert them into signals
|
|
|
|
|
* appropriate for a given connector or set of connectors.
|
2008-11-08 06:05:41 +08:00
|
|
|
*/
|
|
|
|
|
struct drm_encoder {
|
|
|
|
|
struct drm_device *dev;
|
|
|
|
|
struct list_head head;
|
|
|
|
|
|
|
|
|
|
struct drm_mode_object base;
|
2014-05-14 21:58:20 +08:00
|
|
|
char *name;
|
2008-11-08 06:05:41 +08:00
|
|
|
int encoder_type;
|
|
|
|
|
uint32_t possible_crtcs;
|
|
|
|
|
uint32_t possible_clones;
|
|
|
|
|
|
|
|
|
|
struct drm_crtc *crtc;
|
2013-08-15 04:47:37 +08:00
|
|
|
struct drm_bridge *bridge;
|
2008-11-08 06:05:41 +08:00
|
|
|
const struct drm_encoder_funcs *funcs;
|
|
|
|
|
void *helper_private;
|
|
|
|
|
};
|
|
|
|
|
|
2010-05-07 14:42:51 +08:00
|
|
|
/* should we poll this connector for connects and disconnects */
|
|
|
|
|
/* hot plug detectable */
|
|
|
|
|
#define DRM_CONNECTOR_POLL_HPD (1 << 0)
|
|
|
|
|
/* poll for connections */
|
|
|
|
|
#define DRM_CONNECTOR_POLL_CONNECT (1 << 1)
|
|
|
|
|
/* can cleanly poll for disconnections without flickering the screen */
|
|
|
|
|
/* DACs should rarely do this without a lot of testing */
|
|
|
|
|
#define DRM_CONNECTOR_POLL_DISCONNECT (1 << 2)
|
|
|
|
|
|
2011-09-05 14:23:20 +08:00
|
|
|
#define MAX_ELD_BYTES 128
|
|
|
|
|
|
2008-11-08 06:05:41 +08:00
|
|
|
/**
|
2014-10-27 23:54:27 +08:00
|
|
|
* struct drm_connector - central DRM connector control structure
|
2011-11-08 04:03:18 +08:00
|
|
|
* @dev: parent DRM device
|
|
|
|
|
* @kdev: kernel device for sysfs attributes
|
|
|
|
|
* @attr: sysfs attributes
|
|
|
|
|
* @head: list management
|
|
|
|
|
* @base: base KMS object
|
2014-05-14 21:58:19 +08:00
|
|
|
* @name: connector name
|
2011-11-08 04:03:18 +08:00
|
|
|
* @connector_type: one of the %DRM_MODE_CONNECTOR_<foo> types from drm_mode.h
|
|
|
|
|
* @connector_type_id: index into connector type enum
|
2008-11-08 06:05:41 +08:00
|
|
|
* @interlace_allowed: can this connector handle interlaced modes?
|
|
|
|
|
* @doublescan_allowed: can this connector handle doublescan?
|
2014-10-28 03:19:38 +08:00
|
|
|
* @stereo_allowed: can this connector handle stereo modes?
|
2011-11-08 04:03:18 +08:00
|
|
|
* @modes: modes available on this connector (from fill_modes() + user)
|
|
|
|
|
* @status: one of the drm_connector_status enums (connected, not, or unknown)
|
|
|
|
|
* @probed_modes: list of modes derived directly from the display
|
|
|
|
|
* @display_info: information about attached display (e.g. from EDID)
|
2008-11-08 06:05:41 +08:00
|
|
|
* @funcs: connector control functions
|
2011-11-08 04:03:18 +08:00
|
|
|
* @edid_blob_ptr: DRM property containing EDID if present
|
2012-05-16 05:09:01 +08:00
|
|
|
* @properties: property tracking for this connector
|
2014-10-28 03:19:38 +08:00
|
|
|
* @path_blob_ptr: DRM blob property data for the DP MST path property
|
2011-11-08 04:03:18 +08:00
|
|
|
* @polled: a %DRM_CONNECTOR_POLL_<foo> value for core driven polling
|
|
|
|
|
* @dpms: current dpms state
|
|
|
|
|
* @helper_private: mid-layer private data
|
2014-10-28 03:19:38 +08:00
|
|
|
* @cmdline_mode: mode line parsed from the kernel cmdline for this connector
|
2011-11-08 04:03:18 +08:00
|
|
|
* @force: a %DRM_FORCE_<foo> state for forced mode sets
|
2014-10-28 03:19:38 +08:00
|
|
|
* @override_edid: has the EDID been overwritten through debugfs for testing?
|
2011-11-08 04:03:18 +08:00
|
|
|
* @encoder_ids: valid encoders for this connector
|
|
|
|
|
* @encoder: encoder driving this connector, if any
|
|
|
|
|
* @eld: EDID-like data, if present
|
|
|
|
|
* @dvi_dual: dual link DVI, if found
|
|
|
|
|
* @max_tmds_clock: max clock rate, if found
|
|
|
|
|
* @latency_present: AV delay info from ELD, if found
|
|
|
|
|
* @video_latency: video latency info from ELD, if found
|
|
|
|
|
* @audio_latency: audio latency info from ELD, if found
|
|
|
|
|
* @null_edid_counter: track sinks that give us all zeros for the EDID
|
2014-10-28 03:19:38 +08:00
|
|
|
* @bad_edid_counter: track sinks that give us an EDID with invalid checksum
|
|
|
|
|
* @debugfs_entry: debugfs directory for this connector
|
2014-10-28 03:28:44 +08:00
|
|
|
* @state: current atomic state for this connector
|
2014-10-20 14:29:33 +08:00
|
|
|
* @has_tile: is this connector connected to a tiled monitor
|
|
|
|
|
* @tile_group: tile group for the connected monitor
|
|
|
|
|
* @tile_is_single_monitor: whether the tile is one monitor housing
|
|
|
|
|
* @num_h_tile: number of horizontal tiles in the tile group
|
|
|
|
|
* @num_v_tile: number of vertical tiles in the tile group
|
|
|
|
|
* @tile_h_loc: horizontal location of this tile
|
|
|
|
|
* @tile_v_loc: vertical location of this tile
|
|
|
|
|
* @tile_h_size: horizontal size of this tile.
|
|
|
|
|
* @tile_v_size: vertical size of this tile.
|
2008-11-08 06:05:41 +08:00
|
|
|
*
|
|
|
|
|
* Each connector may be connected to one or more CRTCs, or may be clonable by
|
|
|
|
|
* another connector if they can share a CRTC. Each connector also has a specific
|
|
|
|
|
* position in the broader display (referred to as a 'screen' though it could
|
|
|
|
|
* span multiple monitors).
|
|
|
|
|
*/
|
|
|
|
|
struct drm_connector {
|
|
|
|
|
struct drm_device *dev;
|
2013-10-11 12:07:25 +08:00
|
|
|
struct device *kdev;
|
2008-11-08 06:05:41 +08:00
|
|
|
struct device_attribute *attr;
|
|
|
|
|
struct list_head head;
|
|
|
|
|
|
|
|
|
|
struct drm_mode_object base;
|
|
|
|
|
|
2014-05-14 21:58:19 +08:00
|
|
|
char *name;
|
2008-11-08 06:05:41 +08:00
|
|
|
int connector_type;
|
|
|
|
|
int connector_type_id;
|
|
|
|
|
bool interlace_allowed;
|
|
|
|
|
bool doublescan_allowed;
|
2013-09-25 23:45:29 +08:00
|
|
|
bool stereo_allowed;
|
2008-11-08 06:05:41 +08:00
|
|
|
struct list_head modes; /* list of modes on this connector */
|
|
|
|
|
|
|
|
|
|
enum drm_connector_status status;
|
|
|
|
|
|
|
|
|
|
/* these are modes added by probing with DDC or the BIOS */
|
|
|
|
|
struct list_head probed_modes;
|
|
|
|
|
|
|
|
|
|
struct drm_display_info display_info;
|
|
|
|
|
const struct drm_connector_funcs *funcs;
|
|
|
|
|
|
|
|
|
|
struct drm_property_blob *edid_blob_ptr;
|
2012-05-16 05:09:01 +08:00
|
|
|
struct drm_object_properties properties;
|
2008-11-08 06:05:41 +08:00
|
|
|
|
2014-06-05 12:01:31 +08:00
|
|
|
struct drm_property_blob *path_blob_ptr;
|
|
|
|
|
|
2014-10-20 14:30:50 +08:00
|
|
|
struct drm_property_blob *tile_blob_ptr;
|
|
|
|
|
|
2010-05-07 14:42:51 +08:00
|
|
|
uint8_t polled; /* DRM_CONNECTOR_POLL_* */
|
|
|
|
|
|
2009-05-31 11:42:28 +08:00
|
|
|
/* requested DPMS state */
|
|
|
|
|
int dpms;
|
|
|
|
|
|
2008-11-08 06:05:41 +08:00
|
|
|
void *helper_private;
|
|
|
|
|
|
drm/kms: start adding command line interface using fb.
[note this requires an fb patch posted to linux-fbdev-devel already]
This uses the normal video= command line option to control the kms
output setup at boot time. It is used to override the autodetection
done by kms.
video= normally takes a framebuffer as the first parameter, in kms
it will take a connector name, DVI-I-1, or LVDS-1 etc. If no output
connector is specified the mode string will apply to all connectors.
The mode specification used will match down the probed modes, and if
no mode is found it will add a CVT mode that matches.
video=1024x768 - all connectors match a 1024x768 mode or add a CVT on
video=VGA-1:1024x768, VGA-1 connector gets mode only.
The same strings as used in current fb modedb.c are used, except I've
added three more letters, e, D, d, e = enable, D = enable Digital,
d = disable, which allow a connector to be forced into a certain state.
Signed-off-by: Dave Airlie <airlied@redhat.com>
2009-09-23 12:44:08 +08:00
|
|
|
/* forced on connector */
|
2014-08-06 16:08:32 +08:00
|
|
|
struct drm_cmdline_mode cmdline_mode;
|
drm/kms: start adding command line interface using fb.
[note this requires an fb patch posted to linux-fbdev-devel already]
This uses the normal video= command line option to control the kms
output setup at boot time. It is used to override the autodetection
done by kms.
video= normally takes a framebuffer as the first parameter, in kms
it will take a connector name, DVI-I-1, or LVDS-1 etc. If no output
connector is specified the mode string will apply to all connectors.
The mode specification used will match down the probed modes, and if
no mode is found it will add a CVT mode that matches.
video=1024x768 - all connectors match a 1024x768 mode or add a CVT on
video=VGA-1:1024x768, VGA-1 connector gets mode only.
The same strings as used in current fb modedb.c are used, except I've
added three more letters, e, D, d, e = enable, D = enable Digital,
d = disable, which allow a connector to be forced into a certain state.
Signed-off-by: Dave Airlie <airlied@redhat.com>
2009-09-23 12:44:08 +08:00
|
|
|
enum drm_connector_force force;
|
2014-06-19 00:52:33 +08:00
|
|
|
bool override_edid;
|
2008-11-08 06:05:41 +08:00
|
|
|
uint32_t encoder_ids[DRM_CONNECTOR_MAX_ENCODER];
|
|
|
|
|
struct drm_encoder *encoder; /* currently active encoder */
|
2011-06-14 14:13:55 +08:00
|
|
|
|
2011-09-05 14:23:20 +08:00
|
|
|
/* EDID bits */
|
|
|
|
|
uint8_t eld[MAX_ELD_BYTES];
|
|
|
|
|
bool dvi_dual;
|
|
|
|
|
int max_tmds_clock; /* in MHz */
|
|
|
|
|
bool latency_present[2];
|
|
|
|
|
int video_latency[2]; /* [0]: progressive, [1]: interlaced */
|
|
|
|
|
int audio_latency[2];
|
2011-06-14 14:13:55 +08:00
|
|
|
int null_edid_counter; /* needed to workaround some HW bugs where we get all 0s */
|
2012-08-09 23:25:51 +08:00
|
|
|
unsigned bad_edid_counter;
|
2014-06-19 00:52:32 +08:00
|
|
|
|
|
|
|
|
struct dentry *debugfs_entry;
|
2014-10-28 03:28:44 +08:00
|
|
|
|
|
|
|
|
struct drm_connector_state *state;
|
2014-10-20 14:29:33 +08:00
|
|
|
|
|
|
|
|
/* DisplayID bits */
|
|
|
|
|
bool has_tile;
|
|
|
|
|
struct drm_tile_group *tile_group;
|
|
|
|
|
bool tile_is_single_monitor;
|
|
|
|
|
|
|
|
|
|
uint8_t num_h_tile, num_v_tile;
|
|
|
|
|
uint8_t tile_h_loc, tile_v_loc;
|
|
|
|
|
uint16_t tile_h_size, tile_v_size;
|
2014-10-28 03:28:44 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* struct drm_plane_state - mutable plane state
|
2014-11-27 22:49:39 +08:00
|
|
|
* @plane: backpointer to the plane
|
2014-10-28 03:28:44 +08:00
|
|
|
* @crtc: currently bound CRTC, NULL if disabled
|
2014-07-26 03:30:38 +08:00
|
|
|
* @fb: currently bound framebuffer
|
2014-10-29 18:34:56 +08:00
|
|
|
* @fence: optional fence to wait for before scanning out @fb
|
2014-10-28 03:28:44 +08: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)
|
|
|
|
|
* @state: backpointer to global drm_atomic_state
|
|
|
|
|
*/
|
|
|
|
|
struct drm_plane_state {
|
2014-11-27 22:49:39 +08:00
|
|
|
struct drm_plane *plane;
|
|
|
|
|
|
2014-11-22 04:28:31 +08: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 18:34:56 +08:00
|
|
|
struct fence *fence;
|
2014-10-28 03:28:44 +08: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;
|
|
|
|
|
|
|
|
|
|
struct drm_atomic_state *state;
|
2008-11-08 06:05:41 +08:00
|
|
|
};
|
|
|
|
|
|
2014-10-28 03:28:44 +08:00
|
|
|
|
2011-11-15 06:51:27 +08:00
|
|
|
/**
|
2014-10-27 23:54:27 +08:00
|
|
|
* struct drm_plane_funcs - driver plane control functions
|
2011-11-15 06:51:27 +08:00
|
|
|
* @update_plane: update the plane configuration
|
|
|
|
|
* @disable_plane: shut down the plane
|
|
|
|
|
* @destroy: clean up plane resources
|
2014-10-28 03:19:38 +08:00
|
|
|
* @reset: reset plane after state has been invalidated (e.g. resume)
|
2012-05-17 16:23:27 +08:00
|
|
|
* @set_property: called when a property is changed
|
2014-10-28 03:28:44 +08:00
|
|
|
* @atomic_duplicate_state: duplicate the atomic state for this plane
|
|
|
|
|
* @atomic_destroy_state: destroy an atomic state for this plane
|
|
|
|
|
* @atomic_set_property: set a property on an atomic state for this plane
|
2014-12-19 05:01:46 +08:00
|
|
|
* (do not call directly, use drm_atomic_plane_set_property())
|
2014-12-19 05:01:47 +08:00
|
|
|
* @atomic_get_property: get a property on an atomic state for this plane
|
|
|
|
|
* (do not call directly, use drm_atomic_plane_get_property())
|
2011-11-15 06:51:27 +08:00
|
|
|
*/
|
|
|
|
|
struct drm_plane_funcs {
|
|
|
|
|
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);
|
|
|
|
|
int (*disable_plane)(struct drm_plane *plane);
|
|
|
|
|
void (*destroy)(struct drm_plane *plane);
|
2014-07-29 21:32:37 +08:00
|
|
|
void (*reset)(struct drm_plane *plane);
|
2012-05-17 16:23:27 +08:00
|
|
|
|
|
|
|
|
int (*set_property)(struct drm_plane *plane,
|
|
|
|
|
struct drm_property *property, uint64_t val);
|
2014-10-28 03:28:44 +08:00
|
|
|
|
|
|
|
|
/* atomic update handling */
|
|
|
|
|
struct drm_plane_state *(*atomic_duplicate_state)(struct drm_plane *plane);
|
|
|
|
|
void (*atomic_destroy_state)(struct drm_plane *plane,
|
2014-07-26 03:30:38 +08:00
|
|
|
struct drm_plane_state *state);
|
2014-10-28 03:28:44 +08:00
|
|
|
int (*atomic_set_property)(struct drm_plane *plane,
|
|
|
|
|
struct drm_plane_state *state,
|
|
|
|
|
struct drm_property *property,
|
|
|
|
|
uint64_t val);
|
2014-12-19 05:01:47 +08:00
|
|
|
int (*atomic_get_property)(struct drm_plane *plane,
|
|
|
|
|
const struct drm_plane_state *state,
|
|
|
|
|
struct drm_property *property,
|
|
|
|
|
uint64_t *val);
|
2011-11-15 06:51:27 +08:00
|
|
|
};
|
|
|
|
|
|
2014-04-02 06:22:30 +08:00
|
|
|
enum drm_plane_type {
|
|
|
|
|
DRM_PLANE_TYPE_OVERLAY,
|
|
|
|
|
DRM_PLANE_TYPE_PRIMARY,
|
|
|
|
|
DRM_PLANE_TYPE_CURSOR,
|
|
|
|
|
};
|
|
|
|
|
|
2011-11-15 06:51:27 +08:00
|
|
|
/**
|
2014-10-27 23:54:27 +08:00
|
|
|
* struct drm_plane - central DRM plane control structure
|
2011-11-15 06:51:27 +08:00
|
|
|
* @dev: DRM device this plane belongs to
|
|
|
|
|
* @head: for list management
|
|
|
|
|
* @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
|
|
|
|
|
* @crtc: currently bound CRTC
|
|
|
|
|
* @fb: currently bound fb
|
2014-10-28 03:19:38 +08: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-15 06:51:27 +08:00
|
|
|
* @funcs: helper functions
|
2012-05-17 16:23:27 +08:00
|
|
|
* @properties: property tracking for this plane
|
2014-04-02 06:22:30 +08:00
|
|
|
* @type: type of plane (overlay, primary, cursor)
|
2014-10-28 03:28:44 +08:00
|
|
|
* @state: current atomic state for this plane
|
2011-11-15 06:51:27 +08:00
|
|
|
*/
|
|
|
|
|
struct drm_plane {
|
|
|
|
|
struct drm_device *dev;
|
|
|
|
|
struct list_head head;
|
|
|
|
|
|
2014-11-11 17:12:00 +08:00
|
|
|
struct drm_modeset_lock mutex;
|
|
|
|
|
|
2011-11-15 06:51:27 +08:00
|
|
|
struct drm_mode_object base;
|
|
|
|
|
|
|
|
|
|
uint32_t possible_crtcs;
|
|
|
|
|
uint32_t *format_types;
|
|
|
|
|
uint32_t format_count;
|
|
|
|
|
|
|
|
|
|
struct drm_crtc *crtc;
|
|
|
|
|
struct drm_framebuffer *fb;
|
|
|
|
|
|
2014-07-27 19:42:42 +08:00
|
|
|
struct drm_framebuffer *old_fb;
|
|
|
|
|
|
2011-11-15 06:51:27 +08:00
|
|
|
const struct drm_plane_funcs *funcs;
|
2012-05-17 16:23:27 +08:00
|
|
|
|
|
|
|
|
struct drm_object_properties properties;
|
2014-04-02 06:22:30 +08:00
|
|
|
|
|
|
|
|
enum drm_plane_type type;
|
2014-10-28 03:28:44 +08:00
|
|
|
|
2014-11-05 07:14:14 +08:00
|
|
|
void *helper_private;
|
|
|
|
|
|
2014-10-28 03:28:44 +08:00
|
|
|
struct drm_plane_state *state;
|
2011-11-15 06:51:27 +08:00
|
|
|
};
|
|
|
|
|
|
2013-08-15 04:47:37 +08:00
|
|
|
/**
|
2014-10-27 23:54:27 +08:00
|
|
|
* struct drm_bridge_funcs - drm_bridge control functions
|
2013-08-15 04:47:37 +08:00
|
|
|
* @mode_fixup: Try to fixup (or reject entirely) proposed mode for this bridge
|
|
|
|
|
* @disable: Called right before encoder prepare, disables the bridge
|
|
|
|
|
* @post_disable: Called right after encoder prepare, for lockstepped disable
|
|
|
|
|
* @mode_set: Set this mode to the bridge
|
|
|
|
|
* @pre_enable: Called right before encoder commit, for lockstepped commit
|
|
|
|
|
* @enable: Called right after encoder commit, enables the bridge
|
|
|
|
|
* @destroy: make object go away
|
|
|
|
|
*/
|
|
|
|
|
struct drm_bridge_funcs {
|
|
|
|
|
bool (*mode_fixup)(struct drm_bridge *bridge,
|
|
|
|
|
const struct drm_display_mode *mode,
|
|
|
|
|
struct drm_display_mode *adjusted_mode);
|
|
|
|
|
void (*disable)(struct drm_bridge *bridge);
|
|
|
|
|
void (*post_disable)(struct drm_bridge *bridge);
|
|
|
|
|
void (*mode_set)(struct drm_bridge *bridge,
|
|
|
|
|
struct drm_display_mode *mode,
|
|
|
|
|
struct drm_display_mode *adjusted_mode);
|
|
|
|
|
void (*pre_enable)(struct drm_bridge *bridge);
|
|
|
|
|
void (*enable)(struct drm_bridge *bridge);
|
|
|
|
|
void (*destroy)(struct drm_bridge *bridge);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/**
|
2014-10-27 23:54:27 +08:00
|
|
|
* struct drm_bridge - central DRM bridge control structure
|
2013-08-15 04:47:37 +08:00
|
|
|
* @dev: DRM device this bridge belongs to
|
|
|
|
|
* @head: list management
|
|
|
|
|
* @base: base mode object
|
|
|
|
|
* @funcs: control functions
|
|
|
|
|
* @driver_private: pointer to the bridge driver's internal context
|
|
|
|
|
*/
|
|
|
|
|
struct drm_bridge {
|
|
|
|
|
struct drm_device *dev;
|
|
|
|
|
struct list_head head;
|
|
|
|
|
|
|
|
|
|
struct drm_mode_object base;
|
|
|
|
|
|
|
|
|
|
const struct drm_bridge_funcs *funcs;
|
|
|
|
|
void *driver_private;
|
|
|
|
|
};
|
|
|
|
|
|
2014-07-26 03:30:38 +08:00
|
|
|
/**
|
|
|
|
|
* struct struct drm_atomic_state - the global state object for atomic updates
|
|
|
|
|
* @dev: parent DRM device
|
2014-12-19 05:01:56 +08:00
|
|
|
* @allow_modeset: allow full modeset
|
2014-07-26 03:30:38 +08:00
|
|
|
* @planes: pointer to array of plane pointers
|
|
|
|
|
* @plane_states: pointer to array of plane states pointers
|
|
|
|
|
* @crtcs: pointer to array of CRTC pointers
|
|
|
|
|
* @crtc_states: pointer to array of CRTC states pointers
|
2014-11-20 01:38:08 +08:00
|
|
|
* @num_connector: size of the @connectors and @connector_states arrays
|
2014-07-26 03:30:38 +08:00
|
|
|
* @connectors: pointer to array of connector pointers
|
|
|
|
|
* @connector_states: pointer to array of connector states pointers
|
|
|
|
|
* @acquire_ctx: acquire context for this atomic modeset state update
|
|
|
|
|
*/
|
|
|
|
|
struct drm_atomic_state {
|
|
|
|
|
struct drm_device *dev;
|
2014-12-19 05:01:56 +08:00
|
|
|
bool allow_modeset : 1;
|
2014-07-26 03:30:38 +08:00
|
|
|
struct drm_plane **planes;
|
|
|
|
|
struct drm_plane_state **plane_states;
|
|
|
|
|
struct drm_crtc **crtcs;
|
|
|
|
|
struct drm_crtc_state **crtc_states;
|
2014-11-20 01:38:08 +08:00
|
|
|
int num_connector;
|
2014-07-26 03:30:38 +08:00
|
|
|
struct drm_connector **connectors;
|
|
|
|
|
struct drm_connector_state **connector_states;
|
|
|
|
|
|
|
|
|
|
struct drm_modeset_acquire_ctx *acquire_ctx;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
2008-11-08 06:05:41 +08:00
|
|
|
/**
|
2014-10-27 23:54:27 +08:00
|
|
|
* struct drm_mode_set - new values for a CRTC config change
|
2011-11-08 04:03:19 +08:00
|
|
|
* @fb: framebuffer to use for new config
|
|
|
|
|
* @crtc: CRTC whose configuration we're about to change
|
|
|
|
|
* @mode: mode timings to use
|
|
|
|
|
* @x: position of this CRTC relative to @fb
|
|
|
|
|
* @y: position of this CRTC relative to @fb
|
|
|
|
|
* @connectors: array of connectors to drive with this CRTC if possible
|
|
|
|
|
* @num_connectors: size of @connectors array
|
2008-11-08 06:05:41 +08: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-08 04:03:20 +08:00
|
|
|
* struct drm_mode_config_funcs - basic driver provided mode setting functions
|
|
|
|
|
* @fb_create: create a new framebuffer object
|
|
|
|
|
* @output_poll_changed: function to handle output configuration changes
|
2014-07-26 03:30:38 +08:00
|
|
|
* @atomic_check: check whether a give atomic state update is possible
|
|
|
|
|
* @atomic_commit: commit an atomic state update previously verified with
|
|
|
|
|
* atomic_check()
|
2011-11-08 04:03:20 +08:00
|
|
|
*
|
|
|
|
|
* Some global (i.e. not per-CRTC, connector, etc) mode setting functions that
|
|
|
|
|
* involve drivers.
|
2008-11-08 06:05:41 +08:00
|
|
|
*/
|
|
|
|
|
struct drm_mode_config_funcs {
|
2011-11-08 04:03:20 +08:00
|
|
|
struct drm_framebuffer *(*fb_create)(struct drm_device *dev,
|
|
|
|
|
struct drm_file *file_priv,
|
|
|
|
|
struct drm_mode_fb_cmd2 *mode_cmd);
|
2010-05-07 14:42:51 +08:00
|
|
|
void (*output_poll_changed)(struct drm_device *dev);
|
2014-07-26 03:30:38 +08:00
|
|
|
|
|
|
|
|
int (*atomic_check)(struct drm_device *dev,
|
|
|
|
|
struct drm_atomic_state *a);
|
|
|
|
|
int (*atomic_commit)(struct drm_device *dev,
|
|
|
|
|
struct drm_atomic_state *a,
|
|
|
|
|
bool async);
|
2008-11-08 06:05:41 +08:00
|
|
|
};
|
|
|
|
|
|
2011-11-08 04:03:21 +08:00
|
|
|
/**
|
2014-10-28 03:19:38 +08:00
|
|
|
* struct drm_mode_group - group of mode setting resources for potential sub-grouping
|
2011-11-08 04:03:21 +08:00
|
|
|
* @num_crtcs: CRTC count
|
|
|
|
|
* @num_encoders: encoder count
|
|
|
|
|
* @num_connectors: connector count
|
2014-10-28 03:19:38 +08:00
|
|
|
* @num_bridges: bridge count
|
2011-11-08 04:03:21 +08:00
|
|
|
* @id_list: list of KMS object IDs in this group
|
|
|
|
|
*
|
|
|
|
|
* Currently this simply tracks the global mode setting state. But in the
|
|
|
|
|
* future it could allow groups of objects to be set aside into independent
|
|
|
|
|
* control groups for use by different user level processes (e.g. two X servers
|
|
|
|
|
* running simultaneously on different heads, each with their own mode
|
|
|
|
|
* configuration and freedom of mode setting).
|
|
|
|
|
*/
|
2008-11-08 06:05:41 +08:00
|
|
|
struct drm_mode_group {
|
|
|
|
|
uint32_t num_crtcs;
|
|
|
|
|
uint32_t num_encoders;
|
|
|
|
|
uint32_t num_connectors;
|
2013-08-15 04:47:37 +08:00
|
|
|
uint32_t num_bridges;
|
2008-11-08 06:05:41 +08:00
|
|
|
|
|
|
|
|
/* list of object IDs for this group */
|
|
|
|
|
uint32_t *id_list;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/**
|
2014-10-28 03:19:38 +08:00
|
|
|
* struct drm_mode_config - Mode configuration control structure
|
2011-11-08 04:03:22 +08:00
|
|
|
* @mutex: mutex protecting KMS related lists and structures
|
2014-10-28 03:19:38 +08:00
|
|
|
* @connection_mutex: ww mutex protecting connector state and routing
|
|
|
|
|
* @acquire_ctx: global implicit acquire context used by atomic drivers for
|
|
|
|
|
* legacy ioctls
|
2011-11-08 04:03:22 +08:00
|
|
|
* @idr_mutex: mutex for KMS ID allocation and management
|
|
|
|
|
* @crtc_idr: main KMS ID tracking object
|
2014-10-28 03:19:38 +08:00
|
|
|
* @fb_lock: mutex to protect fb state and lists
|
2011-11-08 04:03:22 +08:00
|
|
|
* @num_fb: number of fbs available
|
|
|
|
|
* @fb_list: list of framebuffers available
|
|
|
|
|
* @num_connector: number of connectors on this device
|
|
|
|
|
* @connector_list: list of connector objects
|
2013-08-15 04:47:37 +08:00
|
|
|
* @num_bridge: number of bridges on this device
|
|
|
|
|
* @bridge_list: list of bridge objects
|
2011-11-08 04:03:22 +08:00
|
|
|
* @num_encoder: number of encoders on this device
|
|
|
|
|
* @encoder_list: list of encoder objects
|
2014-10-28 03:19:38 +08: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-08 04:03:22 +08:00
|
|
|
* @num_crtc: number of CRTCs on this device
|
|
|
|
|
* @crtc_list: list of CRTC objects
|
2014-10-28 03:19:38 +08:00
|
|
|
* @property_list: list of property objects
|
2011-11-08 04:03:22 +08: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-28 03:19:38 +08:00
|
|
|
* @poll_enabled: track polling support for this device
|
|
|
|
|
* @poll_running: track polling status for this device
|
2011-11-08 04:03:22 +08:00
|
|
|
* @output_poll_work: delayed work for polling in process context
|
2014-10-28 03:19:38 +08:00
|
|
|
* @property_blob_list: list of all the blob property objects
|
2011-11-08 04:03:22 +08:00
|
|
|
* @*_property: core property tracking
|
2014-10-28 03:19:38 +08:00
|
|
|
* @preferred_depth: preferred RBG pixel depth, used by fb helpers
|
|
|
|
|
* @prefer_shadow: hint to userspace to prefer shadow-fb rendering
|
|
|
|
|
* @async_page_flip: does this device support async flips on the primary plane?
|
|
|
|
|
* @cursor_width: hint to userspace for max cursor width
|
|
|
|
|
* @cursor_height: hint to userspace for max cursor height
|
2008-11-08 06:05:41 +08:00
|
|
|
*
|
2011-11-08 04:03:22 +08: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-08 06:05:41 +08:00
|
|
|
*/
|
|
|
|
|
struct drm_mode_config {
|
2009-01-19 15:21:45 +08:00
|
|
|
struct mutex mutex; /* protects configuration (mode lists etc.) */
|
2013-11-20 01:10:12 +08: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() */
|
2009-01-19 15:21:45 +08:00
|
|
|
struct mutex idr_mutex; /* for IDR management */
|
2008-11-08 06:05:41 +08:00
|
|
|
struct idr crtc_idr; /* use this idr for all IDs, fb, crtc, connector, modes - just makes life easier */
|
2014-10-20 14:17:17 +08:00
|
|
|
struct idr tile_idr; /* use this idr for all IDs, fb, crtc, connector, modes - just makes life easier */
|
2008-11-08 06:05:41 +08:00
|
|
|
/* this is limited to one for now */
|
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-11 04:19:18 +08:00
|
|
|
|
2014-10-28 03:19:38 +08:00
|
|
|
struct mutex fb_lock; /* proctects global and per-file fb lists */
|
2008-11-08 06:05:41 +08: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-11 04:19:18 +08:00
|
|
|
|
2008-11-08 06:05:41 +08:00
|
|
|
int num_connector;
|
|
|
|
|
struct list_head connector_list;
|
2013-08-15 04:47:37 +08:00
|
|
|
int num_bridge;
|
|
|
|
|
struct list_head bridge_list;
|
2008-11-08 06:05:41 +08:00
|
|
|
int num_encoder;
|
|
|
|
|
struct list_head encoder_list;
|
2014-04-02 06:22:30 +08: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-15 06:51:27 +08:00
|
|
|
struct list_head plane_list;
|
2008-11-08 06:05:41 +08: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 19:27:23 +08:00
|
|
|
const struct drm_mode_config_funcs *funcs;
|
2009-02-02 13:55:45 +08:00
|
|
|
resource_size_t fb_base;
|
2008-11-08 06:05:41 +08:00
|
|
|
|
2010-05-07 14:42:51 +08:00
|
|
|
/* output poll support */
|
|
|
|
|
bool poll_enabled;
|
2012-10-24 02:23:36 +08:00
|
|
|
bool poll_running;
|
2010-07-21 04:09:02 +08:00
|
|
|
struct delayed_work output_poll_work;
|
2010-05-07 14:42:51 +08:00
|
|
|
|
2008-11-08 06:05:41 +08:00
|
|
|
/* pointers to standard properties */
|
|
|
|
|
struct list_head property_blob_list;
|
|
|
|
|
struct drm_property *edid_property;
|
|
|
|
|
struct drm_property *dpms_property;
|
2014-06-05 12:01:31 +08:00
|
|
|
struct drm_property *path_property;
|
2014-10-20 14:30:50 +08:00
|
|
|
struct drm_property *tile_property;
|
2014-04-02 08:16:57 +08:00
|
|
|
struct drm_property *plane_type_property;
|
2014-08-05 13:56:54 +08:00
|
|
|
struct drm_property *rotation_property;
|
2014-12-19 05:01:53 +08:00
|
|
|
struct drm_property *prop_src_x;
|
|
|
|
|
struct drm_property *prop_src_y;
|
|
|
|
|
struct drm_property *prop_src_w;
|
|
|
|
|
struct drm_property *prop_src_h;
|
|
|
|
|
struct drm_property *prop_crtc_x;
|
|
|
|
|
struct drm_property *prop_crtc_y;
|
|
|
|
|
struct drm_property *prop_crtc_w;
|
|
|
|
|
struct drm_property *prop_crtc_h;
|
|
|
|
|
struct drm_property *prop_fb_id;
|
|
|
|
|
struct drm_property *prop_crtc_id;
|
2008-11-08 06:05:41 +08:00
|
|
|
|
|
|
|
|
/* DVI-I properties */
|
|
|
|
|
struct drm_property *dvi_i_subconnector_property;
|
|
|
|
|
struct drm_property *dvi_i_select_subconnector_property;
|
|
|
|
|
|
|
|
|
|
/* TV properties */
|
|
|
|
|
struct drm_property *tv_subconnector_property;
|
|
|
|
|
struct drm_property *tv_select_subconnector_property;
|
|
|
|
|
struct drm_property *tv_mode_property;
|
|
|
|
|
struct drm_property *tv_left_margin_property;
|
|
|
|
|
struct drm_property *tv_right_margin_property;
|
|
|
|
|
struct drm_property *tv_top_margin_property;
|
|
|
|
|
struct drm_property *tv_bottom_margin_property;
|
2009-08-02 10:19:20 +08:00
|
|
|
struct drm_property *tv_brightness_property;
|
|
|
|
|
struct drm_property *tv_contrast_property;
|
|
|
|
|
struct drm_property *tv_flicker_reduction_property;
|
2009-08-12 08:30:10 +08:00
|
|
|
struct drm_property *tv_overscan_property;
|
|
|
|
|
struct drm_property *tv_saturation_property;
|
|
|
|
|
struct drm_property *tv_hue_property;
|
2008-11-08 06:05:41 +08:00
|
|
|
|
|
|
|
|
/* Optional properties */
|
|
|
|
|
struct drm_property *scaling_mode_property;
|
2014-06-11 13:16:48 +08:00
|
|
|
struct drm_property *aspect_ratio_property;
|
2009-12-04 07:25:47 +08:00
|
|
|
struct drm_property *dirty_info_property;
|
2011-09-29 23:20:42 +08:00
|
|
|
|
2014-11-10 08:18:15 +08:00
|
|
|
/* properties for virtual machine layout */
|
|
|
|
|
struct drm_property *suggested_x_property;
|
|
|
|
|
struct drm_property *suggested_y_property;
|
|
|
|
|
|
2011-09-29 23:20:42 +08:00
|
|
|
/* dumb ioctl parameters */
|
|
|
|
|
uint32_t preferred_depth, prefer_shadow;
|
2013-07-23 09:50:00 +08:00
|
|
|
|
|
|
|
|
/* whether async page flip is supported or not */
|
|
|
|
|
bool async_page_flip;
|
2014-02-13 01:48:23 +08:00
|
|
|
|
|
|
|
|
/* cursor size */
|
|
|
|
|
uint32_t cursor_width, cursor_height;
|
2008-11-08 06:05:41 +08:00
|
|
|
};
|
|
|
|
|
|
2014-11-26 09:29:46 +08: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) \
|
|
|
|
|
if ((plane_mask) & (1 << drm_plane_index(plane)))
|
|
|
|
|
|
|
|
|
|
|
2008-11-08 06:05:41 +08:00
|
|
|
#define obj_to_crtc(x) container_of(x, struct drm_crtc, base)
|
|
|
|
|
#define obj_to_connector(x) container_of(x, struct drm_connector, base)
|
|
|
|
|
#define obj_to_encoder(x) container_of(x, struct drm_encoder, base)
|
|
|
|
|
#define obj_to_mode(x) container_of(x, struct drm_display_mode, base)
|
|
|
|
|
#define obj_to_fb(x) container_of(x, struct drm_framebuffer, base)
|
|
|
|
|
#define obj_to_property(x) container_of(x, struct drm_property, base)
|
|
|
|
|
#define obj_to_blob(x) container_of(x, struct drm_property_blob, base)
|
2011-11-15 06:51:27 +08:00
|
|
|
#define obj_to_plane(x) container_of(x, struct drm_plane, base)
|
2008-11-08 06:05:41 +08:00
|
|
|
|
2012-02-06 17:58:17 +08:00
|
|
|
struct drm_prop_enum_list {
|
|
|
|
|
int type;
|
|
|
|
|
char *name;
|
|
|
|
|
};
|
2008-11-08 06:05:41 +08:00
|
|
|
|
2014-04-02 06:22:38 +08:00
|
|
|
extern int drm_crtc_init_with_planes(struct drm_device *dev,
|
|
|
|
|
struct drm_crtc *crtc,
|
|
|
|
|
struct drm_plane *primary,
|
2014-06-10 23:28:11 +08:00
|
|
|
struct drm_plane *cursor,
|
2014-04-02 06:22:38 +08:00
|
|
|
const struct drm_crtc_funcs *funcs);
|
2008-11-08 06:05:41 +08:00
|
|
|
extern void drm_crtc_cleanup(struct drm_crtc *crtc);
|
2014-01-03 05:27:33 +08:00
|
|
|
extern unsigned int drm_crtc_index(struct drm_crtc *crtc);
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* 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-08 06:05:41 +08:00
|
|
|
|
2013-08-08 10:34:48 +08:00
|
|
|
extern void drm_connector_ida_init(void);
|
|
|
|
|
extern void drm_connector_ida_destroy(void);
|
2012-03-13 18:35:48 +08:00
|
|
|
extern int drm_connector_init(struct drm_device *dev,
|
|
|
|
|
struct drm_connector *connector,
|
|
|
|
|
const struct drm_connector_funcs *funcs,
|
|
|
|
|
int connector_type);
|
2014-05-29 23:57:41 +08:00
|
|
|
int drm_connector_register(struct drm_connector *connector);
|
|
|
|
|
void drm_connector_unregister(struct drm_connector *connector);
|
2008-11-08 06:05:41 +08:00
|
|
|
|
|
|
|
|
extern void drm_connector_cleanup(struct drm_connector *connector);
|
2014-07-29 19:47:11 +08:00
|
|
|
extern unsigned int drm_connector_index(struct drm_connector *connector);
|
2012-02-20 22:16:40 +08:00
|
|
|
/* helper to unplug all connectors from sysfs for device */
|
|
|
|
|
extern void drm_connector_unplug_all(struct drm_device *dev);
|
2008-11-08 06:05:41 +08:00
|
|
|
|
2013-08-15 04:47:37 +08:00
|
|
|
extern int drm_bridge_init(struct drm_device *dev, struct drm_bridge *bridge,
|
|
|
|
|
const struct drm_bridge_funcs *funcs);
|
|
|
|
|
extern void drm_bridge_cleanup(struct drm_bridge *bridge);
|
|
|
|
|
|
2012-03-13 18:35:48 +08:00
|
|
|
extern int drm_encoder_init(struct drm_device *dev,
|
|
|
|
|
struct drm_encoder *encoder,
|
|
|
|
|
const struct drm_encoder_funcs *funcs,
|
|
|
|
|
int encoder_type);
|
2008-11-08 06:05:41 +08:00
|
|
|
|
2014-01-13 21:33:20 +08:00
|
|
|
/**
|
|
|
|
|
* drm_encoder_crtc_ok - can a given crtc drive a given encoder?
|
|
|
|
|
* @encoder: encoder to test
|
|
|
|
|
* @crtc: crtc to test
|
|
|
|
|
*
|
|
|
|
|
* Return false if @encoder can't be driven by @crtc, true otherwise.
|
|
|
|
|
*/
|
|
|
|
|
static inline bool drm_encoder_crtc_ok(struct drm_encoder *encoder,
|
|
|
|
|
struct drm_crtc *crtc)
|
|
|
|
|
{
|
|
|
|
|
return !!(encoder->possible_crtcs & drm_crtc_mask(crtc));
|
|
|
|
|
}
|
|
|
|
|
|
2014-04-02 06:22:36 +08:00
|
|
|
extern 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,
|
|
|
|
|
uint32_t format_count,
|
|
|
|
|
enum drm_plane_type type);
|
2011-11-15 06:51:27 +08:00
|
|
|
extern int drm_plane_init(struct drm_device *dev,
|
|
|
|
|
struct drm_plane *plane,
|
|
|
|
|
unsigned long possible_crtcs,
|
|
|
|
|
const struct drm_plane_funcs *funcs,
|
2011-12-14 10:19:36 +08:00
|
|
|
const uint32_t *formats, uint32_t format_count,
|
2014-04-02 06:22:36 +08:00
|
|
|
bool is_primary);
|
2011-11-15 06:51:27 +08:00
|
|
|
extern void drm_plane_cleanup(struct drm_plane *plane);
|
2014-07-29 19:47:11 +08:00
|
|
|
extern unsigned int drm_plane_index(struct drm_plane *plane);
|
2013-06-03 21:10:40 +08:00
|
|
|
extern void drm_plane_force_disable(struct drm_plane *plane);
|
2014-12-02 07:40:09 +08:00
|
|
|
extern void drm_crtc_get_hv_timing(const struct drm_display_mode *mode,
|
|
|
|
|
int *hdisplay, int *vdisplay);
|
2014-04-02 06:22:34 +08:00
|
|
|
extern int drm_crtc_check_viewport(const struct drm_crtc *crtc,
|
|
|
|
|
int x, int y,
|
|
|
|
|
const struct drm_display_mode *mode,
|
|
|
|
|
const struct drm_framebuffer *fb);
|
2011-11-15 06:51:27 +08:00
|
|
|
|
2008-11-08 06:05:41 +08:00
|
|
|
extern void drm_encoder_cleanup(struct drm_encoder *encoder);
|
|
|
|
|
|
2013-06-07 23:43:07 +08:00
|
|
|
extern const char *drm_get_connector_status_name(enum drm_connector_status status);
|
2014-02-11 07:32:44 +08:00
|
|
|
extern const char *drm_get_subpixel_order_name(enum subpixel_order order);
|
2013-06-07 23:43:07 +08:00
|
|
|
extern const char *drm_get_dpms_name(int val);
|
|
|
|
|
extern const char *drm_get_dvi_i_subconnector_name(int val);
|
|
|
|
|
extern const char *drm_get_dvi_i_select_name(int val);
|
|
|
|
|
extern const char *drm_get_tv_subconnector_name(int val);
|
|
|
|
|
extern const char *drm_get_tv_select_name(int val);
|
2009-02-13 03:37:56 +08:00
|
|
|
extern void drm_fb_release(struct drm_file *file_priv);
|
2008-11-08 06:05:41 +08:00
|
|
|
extern int drm_mode_group_init_legacy_group(struct drm_device *dev, struct drm_mode_group *group);
|
2014-05-02 11:22:19 +08:00
|
|
|
extern void drm_mode_group_destroy(struct drm_mode_group *group);
|
2014-06-05 12:01:29 +08:00
|
|
|
extern void drm_reinit_primary_mode_group(struct drm_device *dev);
|
2012-09-18 22:58:47 +08:00
|
|
|
extern bool drm_probe_ddc(struct i2c_adapter *adapter);
|
2008-11-08 06:05:41 +08:00
|
|
|
extern struct edid *drm_get_edid(struct drm_connector *connector,
|
|
|
|
|
struct i2c_adapter *adapter);
|
2013-09-27 20:08:27 +08:00
|
|
|
extern struct edid *drm_edid_duplicate(const struct edid *edid);
|
2008-11-08 06:05:41 +08:00
|
|
|
extern int drm_add_edid_modes(struct drm_connector *connector, struct edid *edid);
|
|
|
|
|
extern void drm_mode_config_init(struct drm_device *dev);
|
2011-01-24 23:11:08 +08:00
|
|
|
extern void drm_mode_config_reset(struct drm_device *dev);
|
2008-11-08 06:05:41 +08:00
|
|
|
extern void drm_mode_config_cleanup(struct drm_device *dev);
|
2014-01-23 22:52:20 +08:00
|
|
|
|
2014-06-05 12:01:31 +08:00
|
|
|
extern int drm_mode_connector_set_path_property(struct drm_connector *connector,
|
2014-05-13 17:38:36 +08:00
|
|
|
const char *path);
|
2014-10-20 14:30:50 +08:00
|
|
|
int drm_mode_connector_set_tile_property(struct drm_connector *connector);
|
2008-11-08 06:05:41 +08:00
|
|
|
extern int drm_mode_connector_update_edid_property(struct drm_connector *connector,
|
2014-05-13 17:38:36 +08:00
|
|
|
const struct edid *edid);
|
2014-05-30 23:34:01 +08:00
|
|
|
|
|
|
|
|
static inline bool drm_property_type_is(struct drm_property *property,
|
|
|
|
|
uint32_t type)
|
|
|
|
|
{
|
|
|
|
|
/* instanceof for props.. handles extended type vs original types: */
|
|
|
|
|
if (property->flags & DRM_MODE_PROP_EXTENDED_TYPE)
|
|
|
|
|
return (property->flags & DRM_MODE_PROP_EXTENDED_TYPE) == type;
|
|
|
|
|
return property->flags & type;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline bool drm_property_type_valid(struct drm_property *property)
|
|
|
|
|
{
|
|
|
|
|
if (property->flags & DRM_MODE_PROP_EXTENDED_TYPE)
|
|
|
|
|
return !(property->flags & DRM_MODE_PROP_LEGACY_TYPE);
|
|
|
|
|
return !!(property->flags & DRM_MODE_PROP_LEGACY_TYPE);
|
|
|
|
|
}
|
|
|
|
|
|
2012-05-16 05:09:02 +08:00
|
|
|
extern int drm_object_property_set_value(struct drm_mode_object *obj,
|
|
|
|
|
struct drm_property *property,
|
|
|
|
|
uint64_t val);
|
|
|
|
|
extern int drm_object_property_get_value(struct drm_mode_object *obj,
|
|
|
|
|
struct drm_property *property,
|
|
|
|
|
uint64_t *value);
|
2008-11-08 06:05:41 +08:00
|
|
|
extern int drm_framebuffer_init(struct drm_device *dev,
|
|
|
|
|
struct drm_framebuffer *fb,
|
|
|
|
|
const struct drm_framebuffer_funcs *funcs);
|
2012-12-03 04:53:40 +08:00
|
|
|
extern struct drm_framebuffer *drm_framebuffer_lookup(struct drm_device *dev,
|
|
|
|
|
uint32_t id);
|
2012-09-06 05:48:38 +08:00
|
|
|
extern void drm_framebuffer_unreference(struct drm_framebuffer *fb);
|
|
|
|
|
extern void drm_framebuffer_reference(struct drm_framebuffer *fb);
|
|
|
|
|
extern void drm_framebuffer_remove(struct drm_framebuffer *fb);
|
2008-11-08 06:05:41 +08:00
|
|
|
extern void drm_framebuffer_cleanup(struct drm_framebuffer *fb);
|
drm: revamp framebuffer cleanup interfaces
We have two classes of framebuffer
- Created by the driver (atm only for fbdev), and the driver holds
onto the last reference count until destruction.
- Created by userspace and associated with a given fd. These
framebuffers will be reaped when their assoiciated fb is closed.
Now these two cases are set up differently, the framebuffers are on
different lists and hence destruction needs to clean up different
things. Also, for userspace framebuffers we remove them from any
current usage, whereas for internal framebuffers it is assumed that
the driver has done this already.
Long story short, we need two different ways to cleanup such drivers.
Three functions are involved in total:
- drm_framebuffer_remove: Convenience function which removes the fb
from all active usage and then drops the passed-in reference.
- drm_framebuffer_unregister_private: Will remove driver-private
framebuffers from relevant lists and drop the corresponding
references. Should be called for driver-private framebuffers before
dropping the last reference (or like for a lot of the drivers where
the fbdev is embedded someplace else, before doing the cleanup
manually).
- drm_framebuffer_cleanup: Final cleanup for both classes of fbs,
should be called by the driver's ->destroy callback once the last
reference is gone.
This patch just rolls out the new interfaces and updates all drivers
(by adding calls to drm_framebuffer_unregister_private at all the
right places)- no functional changes yet. Follow-on patches will move
drm core code around and update the lifetime management for
framebuffers, so that we are no longer required to keep framebuffers
alive by locking mode_config.mutex.
I've also updated the kerneldoc already.
vmwgfx seems to again be a bit special, at least I haven't figured out
how the fbdev support in that driver works. It smells like it's
external though.
v2: The i915 driver creates another private framebuffer in the
load-detect code. Adjust its cleanup code, too.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-11 03:42:17 +08:00
|
|
|
extern void drm_framebuffer_unregister_private(struct drm_framebuffer *fb);
|
2008-11-08 06:05:41 +08:00
|
|
|
|
2012-05-16 05:09:02 +08:00
|
|
|
extern void drm_object_attach_property(struct drm_mode_object *obj,
|
|
|
|
|
struct drm_property *property,
|
|
|
|
|
uint64_t init_val);
|
2008-11-08 06:05:41 +08:00
|
|
|
extern struct drm_property *drm_property_create(struct drm_device *dev, int flags,
|
|
|
|
|
const char *name, int num_values);
|
2012-02-06 17:58:17 +08:00
|
|
|
extern struct drm_property *drm_property_create_enum(struct drm_device *dev, int flags,
|
|
|
|
|
const char *name,
|
2012-05-17 16:23:26 +08:00
|
|
|
const struct drm_prop_enum_list *props,
|
|
|
|
|
int num_values);
|
|
|
|
|
struct drm_property *drm_property_create_bitmask(struct drm_device *dev,
|
|
|
|
|
int flags, const char *name,
|
2012-02-06 17:58:17 +08:00
|
|
|
const struct drm_prop_enum_list *props,
|
2014-07-08 13:01:52 +08:00
|
|
|
int num_props,
|
|
|
|
|
uint64_t supported_bits);
|
2012-02-06 17:58:18 +08:00
|
|
|
struct drm_property *drm_property_create_range(struct drm_device *dev, int flags,
|
|
|
|
|
const char *name,
|
|
|
|
|
uint64_t min, uint64_t max);
|
2012-09-13 11:22:31 +08:00
|
|
|
struct drm_property *drm_property_create_signed_range(struct drm_device *dev,
|
|
|
|
|
int flags, const char *name,
|
|
|
|
|
int64_t min, int64_t max);
|
2014-05-30 23:37:03 +08:00
|
|
|
struct drm_property *drm_property_create_object(struct drm_device *dev,
|
|
|
|
|
int flags, const char *name, uint32_t type);
|
2008-11-08 06:05:41 +08:00
|
|
|
extern void drm_property_destroy(struct drm_device *dev, struct drm_property *property);
|
|
|
|
|
extern int drm_property_add_enum(struct drm_property *property, int index,
|
|
|
|
|
uint64_t value, const char *name);
|
|
|
|
|
extern int drm_mode_create_dvi_i_properties(struct drm_device *dev);
|
2014-10-13 18:45:57 +08:00
|
|
|
extern int drm_mode_create_tv_properties(struct drm_device *dev,
|
|
|
|
|
unsigned int num_modes,
|
|
|
|
|
char *modes[]);
|
2008-11-08 06:05:41 +08:00
|
|
|
extern int drm_mode_create_scaling_mode_property(struct drm_device *dev);
|
2014-06-11 13:16:48 +08:00
|
|
|
extern int drm_mode_create_aspect_ratio_property(struct drm_device *dev);
|
2009-12-04 07:25:47 +08:00
|
|
|
extern int drm_mode_create_dirty_info_property(struct drm_device *dev);
|
2014-11-10 08:18:15 +08:00
|
|
|
extern int drm_mode_create_suggested_offset_properties(struct drm_device *dev);
|
2014-12-19 05:01:56 +08:00
|
|
|
extern bool drm_property_change_valid_get(struct drm_property *property,
|
|
|
|
|
uint64_t value, struct drm_mode_object **ref);
|
|
|
|
|
extern void drm_property_change_valid_put(struct drm_property *property,
|
|
|
|
|
struct drm_mode_object *ref);
|
2008-11-08 06:05:41 +08:00
|
|
|
|
|
|
|
|
extern int drm_mode_connector_attach_encoder(struct drm_connector *connector,
|
|
|
|
|
struct drm_encoder *encoder);
|
2012-02-01 18:38:23 +08:00
|
|
|
extern int drm_mode_crtc_set_gamma_size(struct drm_crtc *crtc,
|
2008-11-08 06:05:41 +08:00
|
|
|
int gamma_size);
|
2009-09-16 04:57:31 +08:00
|
|
|
extern struct drm_mode_object *drm_mode_object_find(struct drm_device *dev,
|
|
|
|
|
uint32_t id, uint32_t type);
|
2014-05-30 23:37:03 +08:00
|
|
|
|
2008-11-08 06:05:41 +08:00
|
|
|
/* IOCTLs */
|
|
|
|
|
extern int drm_mode_getresources(struct drm_device *dev,
|
|
|
|
|
void *data, struct drm_file *file_priv);
|
2011-11-15 06:51:27 +08:00
|
|
|
extern int drm_mode_getplane_res(struct drm_device *dev, void *data,
|
|
|
|
|
struct drm_file *file_priv);
|
2008-11-08 06:05:41 +08:00
|
|
|
extern int drm_mode_getcrtc(struct drm_device *dev,
|
|
|
|
|
void *data, struct drm_file *file_priv);
|
|
|
|
|
extern int drm_mode_getconnector(struct drm_device *dev,
|
|
|
|
|
void *data, struct drm_file *file_priv);
|
2012-12-11 20:47:23 +08:00
|
|
|
extern int drm_mode_set_config_internal(struct drm_mode_set *set);
|
2008-11-08 06:05:41 +08:00
|
|
|
extern int drm_mode_setcrtc(struct drm_device *dev,
|
|
|
|
|
void *data, struct drm_file *file_priv);
|
2011-11-15 06:51:27 +08:00
|
|
|
extern int drm_mode_getplane(struct drm_device *dev,
|
|
|
|
|
void *data, struct drm_file *file_priv);
|
|
|
|
|
extern int drm_mode_setplane(struct drm_device *dev,
|
|
|
|
|
void *data, struct drm_file *file_priv);
|
2008-11-08 06:05:41 +08:00
|
|
|
extern int drm_mode_cursor_ioctl(struct drm_device *dev,
|
|
|
|
|
void *data, struct drm_file *file_priv);
|
2013-06-20 09:48:52 +08:00
|
|
|
extern int drm_mode_cursor2_ioctl(struct drm_device *dev,
|
|
|
|
|
void *data, struct drm_file *file_priv);
|
2008-11-08 06:05:41 +08:00
|
|
|
extern int drm_mode_addfb(struct drm_device *dev,
|
|
|
|
|
void *data, struct drm_file *file_priv);
|
2011-11-15 06:51:28 +08:00
|
|
|
extern int drm_mode_addfb2(struct drm_device *dev,
|
|
|
|
|
void *data, struct drm_file *file_priv);
|
|
|
|
|
extern uint32_t drm_mode_legacy_fb_format(uint32_t bpp, uint32_t depth);
|
2008-11-08 06:05:41 +08:00
|
|
|
extern int drm_mode_rmfb(struct drm_device *dev,
|
|
|
|
|
void *data, struct drm_file *file_priv);
|
|
|
|
|
extern int drm_mode_getfb(struct drm_device *dev,
|
|
|
|
|
void *data, struct drm_file *file_priv);
|
2009-12-04 07:25:47 +08:00
|
|
|
extern int drm_mode_dirtyfb_ioctl(struct drm_device *dev,
|
|
|
|
|
void *data, struct drm_file *file_priv);
|
2008-11-08 06:05:41 +08:00
|
|
|
|
|
|
|
|
extern int drm_mode_getproperty_ioctl(struct drm_device *dev,
|
|
|
|
|
void *data, struct drm_file *file_priv);
|
|
|
|
|
extern int drm_mode_getblob_ioctl(struct drm_device *dev,
|
|
|
|
|
void *data, struct drm_file *file_priv);
|
|
|
|
|
extern int drm_mode_connector_property_set_ioctl(struct drm_device *dev,
|
|
|
|
|
void *data, struct drm_file *file_priv);
|
|
|
|
|
extern int drm_mode_getencoder(struct drm_device *dev,
|
|
|
|
|
void *data, struct drm_file *file_priv);
|
|
|
|
|
extern int drm_mode_gamma_get_ioctl(struct drm_device *dev,
|
|
|
|
|
void *data, struct drm_file *file_priv);
|
|
|
|
|
extern int drm_mode_gamma_set_ioctl(struct drm_device *dev,
|
|
|
|
|
void *data, struct drm_file *file_priv);
|
2012-12-20 22:41:44 +08:00
|
|
|
extern u8 drm_match_cea_mode(const struct drm_display_mode *to_match);
|
2014-04-01 18:56:59 +08:00
|
|
|
extern enum hdmi_picture_aspect drm_get_cea_aspect_ratio(const u8 video_code);
|
2009-03-26 19:26:23 +08:00
|
|
|
extern bool drm_detect_hdmi_monitor(struct edid *edid);
|
2010-09-19 14:27:28 +08:00
|
|
|
extern bool drm_detect_monitor_audio(struct edid *edid);
|
2013-01-17 22:31:30 +08:00
|
|
|
extern bool drm_rgb_quant_range_selectable(struct edid *edid);
|
2009-11-18 01:43:55 +08:00
|
|
|
extern int drm_mode_page_flip_ioctl(struct drm_device *dev,
|
|
|
|
|
void *data, struct drm_file *file_priv);
|
2009-09-03 09:33:48 +08:00
|
|
|
extern int drm_add_modes_noedid(struct drm_connector *connector,
|
|
|
|
|
int hdisplay, int vdisplay);
|
2013-10-11 16:01:08 +08:00
|
|
|
extern void drm_set_preferred_mode(struct drm_connector *connector,
|
|
|
|
|
int hpref, int vpref);
|
2010-02-05 17:21:19 +08:00
|
|
|
|
2011-07-29 22:28:57 +08:00
|
|
|
extern int drm_edid_header_is_valid(const u8 *raw_edid);
|
2012-08-09 23:25:51 +08:00
|
|
|
extern bool drm_edid_block_valid(u8 *raw_edid, int block, bool print_bad_edid);
|
2010-02-05 17:21:19 +08:00
|
|
|
extern bool drm_edid_is_valid(struct edid *edid);
|
2014-10-20 14:17:17 +08: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);
|
2010-05-07 13:02:30 +08:00
|
|
|
struct drm_display_mode *drm_mode_find_dmt(struct drm_device *dev,
|
2012-04-14 04:33:31 +08:00
|
|
|
int hsize, int vsize, int fresh,
|
|
|
|
|
bool rb);
|
2011-02-07 10:16:14 +08:00
|
|
|
|
|
|
|
|
extern int drm_mode_create_dumb_ioctl(struct drm_device *dev,
|
|
|
|
|
void *data, struct drm_file *file_priv);
|
|
|
|
|
extern int drm_mode_mmap_dumb_ioctl(struct drm_device *dev,
|
|
|
|
|
void *data, struct drm_file *file_priv);
|
|
|
|
|
extern int drm_mode_destroy_dumb_ioctl(struct drm_device *dev,
|
|
|
|
|
void *data, struct drm_file *file_priv);
|
2012-05-16 05:09:02 +08:00
|
|
|
extern int drm_mode_obj_get_properties_ioctl(struct drm_device *dev, void *data,
|
|
|
|
|
struct drm_file *file_priv);
|
|
|
|
|
extern int drm_mode_obj_set_property_ioctl(struct drm_device *dev, void *data,
|
|
|
|
|
struct drm_file *file_priv);
|
2014-08-20 21:45:00 +08:00
|
|
|
extern int drm_mode_plane_set_obj_prop(struct drm_plane *plane,
|
|
|
|
|
struct drm_property *property,
|
|
|
|
|
uint64_t value);
|
2014-12-19 05:01:56 +08:00
|
|
|
extern int drm_mode_atomic_ioctl(struct drm_device *dev,
|
|
|
|
|
void *data, struct drm_file *file_priv);
|
2011-11-30 04:02:54 +08:00
|
|
|
|
|
|
|
|
extern void drm_fb_get_bpp_depth(uint32_t format, unsigned int *depth,
|
|
|
|
|
int *bpp);
|
2012-04-06 02:35:15 +08:00
|
|
|
extern int drm_format_num_planes(uint32_t format);
|
2012-04-06 02:35:16 +08:00
|
|
|
extern int drm_format_plane_cpp(uint32_t format, int plane);
|
2012-04-06 02:35:17 +08:00
|
|
|
extern int drm_format_horz_chroma_subsampling(uint32_t format);
|
|
|
|
|
extern int drm_format_vert_chroma_subsampling(uint32_t format);
|
2013-06-07 23:43:07 +08:00
|
|
|
extern const char *drm_get_format_name(uint32_t format);
|
2014-07-08 13:01:53 +08:00
|
|
|
extern struct drm_property *drm_mode_create_rotation_property(struct drm_device *dev,
|
|
|
|
|
unsigned int supported_rotations);
|
2014-07-08 13:01:56 +08:00
|
|
|
extern unsigned int drm_rotation_simplify(unsigned int rotation,
|
|
|
|
|
unsigned int supported_rotations);
|
2012-04-06 02:35:15 +08:00
|
|
|
|
2012-08-15 20:59:49 +08:00
|
|
|
/* Helpers */
|
2013-10-06 04:36:52 +08: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 20:59:49 +08: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;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline struct drm_encoder *drm_encoder_find(struct drm_device *dev,
|
|
|
|
|
uint32_t id)
|
|
|
|
|
{
|
|
|
|
|
struct drm_mode_object *mo;
|
|
|
|
|
mo = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_ENCODER);
|
|
|
|
|
return mo ? obj_to_encoder(mo) : NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2013-10-06 04:36:52 +08:00
|
|
|
static inline struct drm_connector *drm_connector_find(struct drm_device *dev,
|
|
|
|
|
uint32_t id)
|
|
|
|
|
{
|
|
|
|
|
struct drm_mode_object *mo;
|
|
|
|
|
mo = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_CONNECTOR);
|
|
|
|
|
return mo ? obj_to_connector(mo) : NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline struct drm_property *drm_property_find(struct drm_device *dev,
|
|
|
|
|
uint32_t id)
|
|
|
|
|
{
|
|
|
|
|
struct drm_mode_object *mo;
|
|
|
|
|
mo = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_PROPERTY);
|
|
|
|
|
return mo ? obj_to_property(mo) : NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline struct drm_property_blob *
|
|
|
|
|
drm_property_blob_find(struct drm_device *dev, uint32_t id)
|
|
|
|
|
{
|
|
|
|
|
struct drm_mode_object *mo;
|
|
|
|
|
mo = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_BLOB);
|
|
|
|
|
return mo ? obj_to_blob(mo) : NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2014-04-02 06:22:30 +08:00
|
|
|
/* Plane list iterator for legacy (overlay only) planes. */
|
|
|
|
|
#define drm_for_each_legacy_plane(plane, planelist) \
|
|
|
|
|
list_for_each_entry(plane, planelist, head) \
|
|
|
|
|
if (plane->type == DRM_PLANE_TYPE_OVERLAY)
|
|
|
|
|
|
2008-11-08 06:05:41 +08:00
|
|
|
#endif /* __DRM_CRTC_H__ */
|