2008-11-07 22:05:41 +00:00
|
|
|
/*
|
|
|
|
|
* Copyright (c) 2006-2008 Intel Corporation
|
|
|
|
|
* Copyright (c) 2007 Dave Airlie <airlied@linux.ie>
|
|
|
|
|
* Copyright (c) 2008 Red Hat Inc.
|
|
|
|
|
*
|
|
|
|
|
* DRM core CRTC related functions
|
|
|
|
|
*
|
|
|
|
|
* Permission to use, copy, modify, distribute, and sell this software and its
|
|
|
|
|
* documentation for any purpose is hereby granted without fee, provided that
|
|
|
|
|
* the above copyright notice appear in all copies and that both that copyright
|
|
|
|
|
* notice and this permission notice appear in supporting documentation, and
|
|
|
|
|
* that the name of the copyright holders not be used in advertising or
|
|
|
|
|
* publicity pertaining to distribution of the software without specific,
|
|
|
|
|
* written prior permission. The copyright holders make no representations
|
|
|
|
|
* about the suitability of this software for any purpose. It is provided "as
|
|
|
|
|
* is" without express or implied warranty.
|
|
|
|
|
*
|
|
|
|
|
* THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
|
|
|
|
|
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
|
|
|
|
|
* EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
|
|
|
|
|
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
|
|
|
|
|
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
|
|
|
|
|
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
|
|
|
|
|
* OF THIS SOFTWARE.
|
|
|
|
|
*
|
|
|
|
|
* Authors:
|
|
|
|
|
* Keith Packard
|
|
|
|
|
* Eric Anholt <eric@anholt.net>
|
|
|
|
|
* Dave Airlie <airlied@linux.ie>
|
|
|
|
|
* Jesse Barnes <jesse.barnes@intel.com>
|
|
|
|
|
*/
|
2013-06-10 08:15:10 +00:00
|
|
|
#include <linux/ctype.h>
|
2008-11-07 22:05:41 +00:00
|
|
|
#include <linux/list.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 08:04:11 +00:00
|
|
|
#include <linux/slab.h>
|
2011-08-30 22:16:33 +00:00
|
|
|
#include <linux/export.h>
|
2012-10-02 17:01:07 +00:00
|
|
|
#include <drm/drmP.h>
|
|
|
|
|
#include <drm/drm_crtc.h>
|
|
|
|
|
#include <drm/drm_edid.h>
|
|
|
|
|
#include <drm/drm_fourcc.h>
|
2013-11-19 17:10:12 +00:00
|
|
|
#include <drm/drm_modeset_lock.h>
|
2008-11-07 22:05:41 +00:00
|
|
|
|
2014-01-23 14:35:24 +00:00
|
|
|
#include "drm_crtc_internal.h"
|
|
|
|
|
|
2012-12-01 23:28:11 +00:00
|
|
|
/**
|
|
|
|
|
* drm_modeset_lock_all - take all modeset locks
|
|
|
|
|
* @dev: drm device
|
|
|
|
|
*
|
|
|
|
|
* This function takes all modeset locks, suitable where a more fine-grained
|
2014-03-10 20:33:02 +00:00
|
|
|
* scheme isn't (yet) implemented. Locks must be dropped with
|
|
|
|
|
* drm_modeset_unlock_all.
|
2012-12-01 23:28:11 +00:00
|
|
|
*/
|
|
|
|
|
void drm_modeset_lock_all(struct drm_device *dev)
|
|
|
|
|
{
|
2013-11-19 17:10:12 +00:00
|
|
|
struct drm_mode_config *config = &dev->mode_config;
|
|
|
|
|
struct drm_modeset_acquire_ctx *ctx;
|
|
|
|
|
int ret;
|
drm: add per-crtc locks
*drumroll*
The basic idea is to protect per-crtc state which can change without
touching the output configuration with separate mutexes, i.e. all the
input side state to a crtc like framebuffers, cursor settings or plane
configuration. Holding such a crtc lock gives a read-lock on all the
other crtc state which can be changed by e.g. a modeset.
All non-crtc state is still protected by the mode_config mutex.
Callers that need to change modeset state of a crtc (e.g. dpms or
set_mode) need to grab both the mode_config lock and nested within any
crtc locks.
Note that since there can only ever be one holder of the mode_config
lock we can grab the subordinate crtc locks in any order (if we need
to grab more than one of them). Lockdep can handle such nesting with
the mutex_lock_nest_lock call correctly.
With this functions that only touch connectors/encoders but not crtcs
only need to take the mode_config lock. The biggest such case is the
output probing, which means that we can now pageflip and move cursors
while the output probe code is reading an edid.
Most cases neatly fall into the three buckets:
- Only touches connectors and similar output state and so only needs
the mode_config lock.
- Touches the global configuration and so needs all locks.
- Only touches the crtc input side and so only needs the crtc lock.
But a few cases that need special consideration:
- Load detection which requires a crtc. The mode_config lock already
prevents a modeset change, so we can use any unused crtc as we like
to do load detection. The only thing to consider is that such
temporary state changes don't leak out to userspace through ioctls
that only take the crtc look (like a pageflip). Hence the load
detect code needs to grab the crtc of any output pipes it touches
(but only if it touches state used by the pageflip or cursor
ioctls).
- Atomic pageflip when moving planes. The first case is sane hw, where
planes have a fixed association with crtcs - nothing needs to be
done there. More insane^Wflexible hw needs to have plane->crtc
mapping which is separately protect with a lock that nests within
the crtc lock. If the plane is unused we can just assign it to the
current crtc and continue. But if a plane is already in use by
another crtc we can't just reassign it.
Two solution present themselves: Either go back to a slow-path which
takes all modeset locks, potentially incure quite a hefty delay. Or
simply disallowing such changes in one atomic pageflip - in general
the vblanks of two crtcs are not synced, so there's no sane way to
atomically flip such plane changes accross more than one crtc. I'd
heavily favour the later approach, going as far as mandating it as
part of the ABI of such a new a nuclear pageflip.
And if we _really_ want such semantics, we can always get them by
introducing another pageflip mutex between the mode_config.mutex and
the individual crtc locks. Pageflips crossing more than one crtc
would then need to take that lock first, to lock out concurrent
multi-crtc pageflips.
- Optimized global modeset operations: We could just take the
mode_config lock and then lazily lock all crtc which are affected by
a modeset operation. This has the advantage that pageflip could
continue unhampered on unaffected crtc. But if e.g. global resources
like plls need to be reassigned and so affect unrelated crtcs we can
still do that - nested locking works in any order.
This patch just adds the locks and takes them in drm_modeset_lock_all,
no real locking changes yet.
v2: Need to initialize the new lock in crtc_init and lock it righ
away, for otherwise the modeset_unlock_all below will try to unlock a
not-locked mutex.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-02 01:18:25 +00:00
|
|
|
|
2013-11-19 17:10:12 +00:00
|
|
|
ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
|
|
|
|
|
if (WARN_ON(!ctx))
|
|
|
|
|
return;
|
drm: add per-crtc locks
*drumroll*
The basic idea is to protect per-crtc state which can change without
touching the output configuration with separate mutexes, i.e. all the
input side state to a crtc like framebuffers, cursor settings or plane
configuration. Holding such a crtc lock gives a read-lock on all the
other crtc state which can be changed by e.g. a modeset.
All non-crtc state is still protected by the mode_config mutex.
Callers that need to change modeset state of a crtc (e.g. dpms or
set_mode) need to grab both the mode_config lock and nested within any
crtc locks.
Note that since there can only ever be one holder of the mode_config
lock we can grab the subordinate crtc locks in any order (if we need
to grab more than one of them). Lockdep can handle such nesting with
the mutex_lock_nest_lock call correctly.
With this functions that only touch connectors/encoders but not crtcs
only need to take the mode_config lock. The biggest such case is the
output probing, which means that we can now pageflip and move cursors
while the output probe code is reading an edid.
Most cases neatly fall into the three buckets:
- Only touches connectors and similar output state and so only needs
the mode_config lock.
- Touches the global configuration and so needs all locks.
- Only touches the crtc input side and so only needs the crtc lock.
But a few cases that need special consideration:
- Load detection which requires a crtc. The mode_config lock already
prevents a modeset change, so we can use any unused crtc as we like
to do load detection. The only thing to consider is that such
temporary state changes don't leak out to userspace through ioctls
that only take the crtc look (like a pageflip). Hence the load
detect code needs to grab the crtc of any output pipes it touches
(but only if it touches state used by the pageflip or cursor
ioctls).
- Atomic pageflip when moving planes. The first case is sane hw, where
planes have a fixed association with crtcs - nothing needs to be
done there. More insane^Wflexible hw needs to have plane->crtc
mapping which is separately protect with a lock that nests within
the crtc lock. If the plane is unused we can just assign it to the
current crtc and continue. But if a plane is already in use by
another crtc we can't just reassign it.
Two solution present themselves: Either go back to a slow-path which
takes all modeset locks, potentially incure quite a hefty delay. Or
simply disallowing such changes in one atomic pageflip - in general
the vblanks of two crtcs are not synced, so there's no sane way to
atomically flip such plane changes accross more than one crtc. I'd
heavily favour the later approach, going as far as mandating it as
part of the ABI of such a new a nuclear pageflip.
And if we _really_ want such semantics, we can always get them by
introducing another pageflip mutex between the mode_config.mutex and
the individual crtc locks. Pageflips crossing more than one crtc
would then need to take that lock first, to lock out concurrent
multi-crtc pageflips.
- Optimized global modeset operations: We could just take the
mode_config lock and then lazily lock all crtc which are affected by
a modeset operation. This has the advantage that pageflip could
continue unhampered on unaffected crtc. But if e.g. global resources
like plls need to be reassigned and so affect unrelated crtcs we can
still do that - nested locking works in any order.
This patch just adds the locks and takes them in drm_modeset_lock_all,
no real locking changes yet.
v2: Need to initialize the new lock in crtc_init and lock it righ
away, for otherwise the modeset_unlock_all below will try to unlock a
not-locked mutex.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-02 01:18:25 +00:00
|
|
|
|
2013-11-19 17:10:12 +00:00
|
|
|
mutex_lock(&config->mutex);
|
drm: Split connection_mutex out of mode_config.mutex (v3)
After the split-out of crtc locks from the big mode_config.mutex
there's still two major areas it protects:
- Various connector probe states, like connector->status, EDID
properties, probed mode lists and similar information.
- The links from connector->encoder and encoder->crtc and other
modeset-relevant connector state (e.g. properties which control the
panel fitter).
The later is used by modeset operations. But they don't really care
about the former since it's allowed to e.g. enable a disconnected VGA
output or with a mode not in the probed list.
Thus far this hasn't been a problem, but for the atomic modeset
conversion Rob Clark needs to convert all modeset relevant locks into
w/w locks. This is required because the order of acquisition is
determined by how userspace supplies the atomic modeset data. This has
run into troubles in the detect path since the i915 load detect code
needs _both_ protections offered by the mode_config.mutex: It updates
probe state and it needs to change the modeset configuration to enable
the temporary load detect pipe.
The big deal here is that for the probe/detect users of this lock a
plain mutex fits best, but for atomic modesets we really want a w/w
mutex. To fix this lets split out a new connection_mutex lock for the
modeset relevant parts.
For simplicity I've decided to only add one additional lock for all
connector/encoder links and modeset configuration states. We have
piles of different modeset objects in addition to those (like bridges
or panels), so adding per-object locks would be much more effort.
Also, we're guaranteed (at least for now) to do a full modeset if we
need to acquire this lock. Which means that fine-grained locking is
fairly irrelevant compared to the amount of time the full modeset will
take.
I've done a full audit, and there's just a few things that justify
special focus:
- Locking in drm_sysfs.c is almost completely absent. We should
sprinkle mode_config.connection_mutex over this file a bit, but
since it already lacks mode_config.mutex this patch wont make the
situation any worse. This is material for a follow-up patch.
- omap has a omap_framebuffer_flush function which walks the
connector->encoder->crtc links and is called from many contexts.
Some look like they don't acquire mode_config.mutex, so this is
already racy. Again fixing this is material for a separate patch.
- The radeon hot_plug function to retrain DP links looks at
connector->dpms. Currently this happens without any locking, so is
already racy. I think radeon_hotplug_work_func should gain
mutex_lock/unlock calls for the mode_config.connection_mutex.
- Same applies to i915's intel_dp_hot_plug. But again, this is already
racy.
- i915 load_detect code needs to acquire this lock. Which means the
w/w dance due to Rob's work will be nicely contained to _just_ this
function.
I've added fixme comments everywhere where it looks suspicious but in
the sysfs code. After a quick irc discussion with Dave Airlie it
sounds like the lack of locking in there is due to sysfs cleanup fun
at module unload.
v1: original (only compile tested)
v2: missing mutex_init(), etc (from Rob Clark)
v3: i915 needs more care in the conversion:
- Protect the edp pp logic with the connection_mutex.
- Use connection_mutex in the backlight code due to
get_pipe_from_connector.
- Use drm_modeset_lock_all in suspend/resume paths.
- Update lock checks in the overlay code.
Cc: Alex Deucher <alexdeucher@gmail.com>
Cc: Rob Clark <robdclark@gmail.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Reviewed-by: Rob Clark <robdclark@gmail.com>
2014-05-29 21:54:47 +00:00
|
|
|
|
2013-11-19 17:10:12 +00:00
|
|
|
drm_modeset_acquire_init(ctx, 0);
|
|
|
|
|
|
|
|
|
|
retry:
|
|
|
|
|
ret = drm_modeset_lock(&config->connection_mutex, ctx);
|
|
|
|
|
if (ret)
|
|
|
|
|
goto fail;
|
|
|
|
|
ret = drm_modeset_lock_all_crtcs(dev, ctx);
|
|
|
|
|
if (ret)
|
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
|
|
WARN_ON(config->acquire_ctx);
|
|
|
|
|
|
|
|
|
|
/* now we hold the locks, so now that it is safe, stash the
|
|
|
|
|
* ctx for drm_modeset_unlock_all():
|
|
|
|
|
*/
|
|
|
|
|
config->acquire_ctx = ctx;
|
|
|
|
|
|
|
|
|
|
drm_warn_on_modeset_not_all_locked(dev);
|
|
|
|
|
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
fail:
|
|
|
|
|
if (ret == -EDEADLK) {
|
|
|
|
|
drm_modeset_backoff(ctx);
|
|
|
|
|
goto retry;
|
|
|
|
|
}
|
2012-12-01 23:28:11 +00:00
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(drm_modeset_lock_all);
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* drm_modeset_unlock_all - drop all modeset locks
|
|
|
|
|
* @dev: device
|
2014-03-10 20:33:02 +00:00
|
|
|
*
|
|
|
|
|
* This function drop all modeset locks taken by drm_modeset_lock_all.
|
2012-12-01 23:28:11 +00:00
|
|
|
*/
|
|
|
|
|
void drm_modeset_unlock_all(struct drm_device *dev)
|
|
|
|
|
{
|
2013-11-19 17:10:12 +00:00
|
|
|
struct drm_mode_config *config = &dev->mode_config;
|
|
|
|
|
struct drm_modeset_acquire_ctx *ctx = config->acquire_ctx;
|
drm: add per-crtc locks
*drumroll*
The basic idea is to protect per-crtc state which can change without
touching the output configuration with separate mutexes, i.e. all the
input side state to a crtc like framebuffers, cursor settings or plane
configuration. Holding such a crtc lock gives a read-lock on all the
other crtc state which can be changed by e.g. a modeset.
All non-crtc state is still protected by the mode_config mutex.
Callers that need to change modeset state of a crtc (e.g. dpms or
set_mode) need to grab both the mode_config lock and nested within any
crtc locks.
Note that since there can only ever be one holder of the mode_config
lock we can grab the subordinate crtc locks in any order (if we need
to grab more than one of them). Lockdep can handle such nesting with
the mutex_lock_nest_lock call correctly.
With this functions that only touch connectors/encoders but not crtcs
only need to take the mode_config lock. The biggest such case is the
output probing, which means that we can now pageflip and move cursors
while the output probe code is reading an edid.
Most cases neatly fall into the three buckets:
- Only touches connectors and similar output state and so only needs
the mode_config lock.
- Touches the global configuration and so needs all locks.
- Only touches the crtc input side and so only needs the crtc lock.
But a few cases that need special consideration:
- Load detection which requires a crtc. The mode_config lock already
prevents a modeset change, so we can use any unused crtc as we like
to do load detection. The only thing to consider is that such
temporary state changes don't leak out to userspace through ioctls
that only take the crtc look (like a pageflip). Hence the load
detect code needs to grab the crtc of any output pipes it touches
(but only if it touches state used by the pageflip or cursor
ioctls).
- Atomic pageflip when moving planes. The first case is sane hw, where
planes have a fixed association with crtcs - nothing needs to be
done there. More insane^Wflexible hw needs to have plane->crtc
mapping which is separately protect with a lock that nests within
the crtc lock. If the plane is unused we can just assign it to the
current crtc and continue. But if a plane is already in use by
another crtc we can't just reassign it.
Two solution present themselves: Either go back to a slow-path which
takes all modeset locks, potentially incure quite a hefty delay. Or
simply disallowing such changes in one atomic pageflip - in general
the vblanks of two crtcs are not synced, so there's no sane way to
atomically flip such plane changes accross more than one crtc. I'd
heavily favour the later approach, going as far as mandating it as
part of the ABI of such a new a nuclear pageflip.
And if we _really_ want such semantics, we can always get them by
introducing another pageflip mutex between the mode_config.mutex and
the individual crtc locks. Pageflips crossing more than one crtc
would then need to take that lock first, to lock out concurrent
multi-crtc pageflips.
- Optimized global modeset operations: We could just take the
mode_config lock and then lazily lock all crtc which are affected by
a modeset operation. This has the advantage that pageflip could
continue unhampered on unaffected crtc. But if e.g. global resources
like plls need to be reassigned and so affect unrelated crtcs we can
still do that - nested locking works in any order.
This patch just adds the locks and takes them in drm_modeset_lock_all,
no real locking changes yet.
v2: Need to initialize the new lock in crtc_init and lock it righ
away, for otherwise the modeset_unlock_all below will try to unlock a
not-locked mutex.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-02 01:18:25 +00:00
|
|
|
|
2013-11-19 17:10:12 +00:00
|
|
|
if (WARN_ON(!ctx))
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
config->acquire_ctx = NULL;
|
|
|
|
|
drm_modeset_drop_locks(ctx);
|
|
|
|
|
drm_modeset_acquire_fini(ctx);
|
drm: add per-crtc locks
*drumroll*
The basic idea is to protect per-crtc state which can change without
touching the output configuration with separate mutexes, i.e. all the
input side state to a crtc like framebuffers, cursor settings or plane
configuration. Holding such a crtc lock gives a read-lock on all the
other crtc state which can be changed by e.g. a modeset.
All non-crtc state is still protected by the mode_config mutex.
Callers that need to change modeset state of a crtc (e.g. dpms or
set_mode) need to grab both the mode_config lock and nested within any
crtc locks.
Note that since there can only ever be one holder of the mode_config
lock we can grab the subordinate crtc locks in any order (if we need
to grab more than one of them). Lockdep can handle such nesting with
the mutex_lock_nest_lock call correctly.
With this functions that only touch connectors/encoders but not crtcs
only need to take the mode_config lock. The biggest such case is the
output probing, which means that we can now pageflip and move cursors
while the output probe code is reading an edid.
Most cases neatly fall into the three buckets:
- Only touches connectors and similar output state and so only needs
the mode_config lock.
- Touches the global configuration and so needs all locks.
- Only touches the crtc input side and so only needs the crtc lock.
But a few cases that need special consideration:
- Load detection which requires a crtc. The mode_config lock already
prevents a modeset change, so we can use any unused crtc as we like
to do load detection. The only thing to consider is that such
temporary state changes don't leak out to userspace through ioctls
that only take the crtc look (like a pageflip). Hence the load
detect code needs to grab the crtc of any output pipes it touches
(but only if it touches state used by the pageflip or cursor
ioctls).
- Atomic pageflip when moving planes. The first case is sane hw, where
planes have a fixed association with crtcs - nothing needs to be
done there. More insane^Wflexible hw needs to have plane->crtc
mapping which is separately protect with a lock that nests within
the crtc lock. If the plane is unused we can just assign it to the
current crtc and continue. But if a plane is already in use by
another crtc we can't just reassign it.
Two solution present themselves: Either go back to a slow-path which
takes all modeset locks, potentially incure quite a hefty delay. Or
simply disallowing such changes in one atomic pageflip - in general
the vblanks of two crtcs are not synced, so there's no sane way to
atomically flip such plane changes accross more than one crtc. I'd
heavily favour the later approach, going as far as mandating it as
part of the ABI of such a new a nuclear pageflip.
And if we _really_ want such semantics, we can always get them by
introducing another pageflip mutex between the mode_config.mutex and
the individual crtc locks. Pageflips crossing more than one crtc
would then need to take that lock first, to lock out concurrent
multi-crtc pageflips.
- Optimized global modeset operations: We could just take the
mode_config lock and then lazily lock all crtc which are affected by
a modeset operation. This has the advantage that pageflip could
continue unhampered on unaffected crtc. But if e.g. global resources
like plls need to be reassigned and so affect unrelated crtcs we can
still do that - nested locking works in any order.
This patch just adds the locks and takes them in drm_modeset_lock_all,
no real locking changes yet.
v2: Need to initialize the new lock in crtc_init and lock it righ
away, for otherwise the modeset_unlock_all below will try to unlock a
not-locked mutex.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-02 01:18:25 +00:00
|
|
|
|
2013-11-19 17:10:12 +00:00
|
|
|
kfree(ctx);
|
drm: Split connection_mutex out of mode_config.mutex (v3)
After the split-out of crtc locks from the big mode_config.mutex
there's still two major areas it protects:
- Various connector probe states, like connector->status, EDID
properties, probed mode lists and similar information.
- The links from connector->encoder and encoder->crtc and other
modeset-relevant connector state (e.g. properties which control the
panel fitter).
The later is used by modeset operations. But they don't really care
about the former since it's allowed to e.g. enable a disconnected VGA
output or with a mode not in the probed list.
Thus far this hasn't been a problem, but for the atomic modeset
conversion Rob Clark needs to convert all modeset relevant locks into
w/w locks. This is required because the order of acquisition is
determined by how userspace supplies the atomic modeset data. This has
run into troubles in the detect path since the i915 load detect code
needs _both_ protections offered by the mode_config.mutex: It updates
probe state and it needs to change the modeset configuration to enable
the temporary load detect pipe.
The big deal here is that for the probe/detect users of this lock a
plain mutex fits best, but for atomic modesets we really want a w/w
mutex. To fix this lets split out a new connection_mutex lock for the
modeset relevant parts.
For simplicity I've decided to only add one additional lock for all
connector/encoder links and modeset configuration states. We have
piles of different modeset objects in addition to those (like bridges
or panels), so adding per-object locks would be much more effort.
Also, we're guaranteed (at least for now) to do a full modeset if we
need to acquire this lock. Which means that fine-grained locking is
fairly irrelevant compared to the amount of time the full modeset will
take.
I've done a full audit, and there's just a few things that justify
special focus:
- Locking in drm_sysfs.c is almost completely absent. We should
sprinkle mode_config.connection_mutex over this file a bit, but
since it already lacks mode_config.mutex this patch wont make the
situation any worse. This is material for a follow-up patch.
- omap has a omap_framebuffer_flush function which walks the
connector->encoder->crtc links and is called from many contexts.
Some look like they don't acquire mode_config.mutex, so this is
already racy. Again fixing this is material for a separate patch.
- The radeon hot_plug function to retrain DP links looks at
connector->dpms. Currently this happens without any locking, so is
already racy. I think radeon_hotplug_work_func should gain
mutex_lock/unlock calls for the mode_config.connection_mutex.
- Same applies to i915's intel_dp_hot_plug. But again, this is already
racy.
- i915 load_detect code needs to acquire this lock. Which means the
w/w dance due to Rob's work will be nicely contained to _just_ this
function.
I've added fixme comments everywhere where it looks suspicious but in
the sysfs code. After a quick irc discussion with Dave Airlie it
sounds like the lack of locking in there is due to sysfs cleanup fun
at module unload.
v1: original (only compile tested)
v2: missing mutex_init(), etc (from Rob Clark)
v3: i915 needs more care in the conversion:
- Protect the edp pp logic with the connection_mutex.
- Use connection_mutex in the backlight code due to
get_pipe_from_connector.
- Use drm_modeset_lock_all in suspend/resume paths.
- Update lock checks in the overlay code.
Cc: Alex Deucher <alexdeucher@gmail.com>
Cc: Rob Clark <robdclark@gmail.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Reviewed-by: Rob Clark <robdclark@gmail.com>
2014-05-29 21:54:47 +00:00
|
|
|
|
2012-12-01 23:28:11 +00:00
|
|
|
mutex_unlock(&dev->mode_config.mutex);
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(drm_modeset_unlock_all);
|
|
|
|
|
|
2013-01-20 16:32:21 +00:00
|
|
|
/**
|
|
|
|
|
* drm_warn_on_modeset_not_all_locked - check that all modeset locks are locked
|
|
|
|
|
* @dev: device
|
2014-03-10 20:33:02 +00:00
|
|
|
*
|
|
|
|
|
* Useful as a debug assert.
|
2013-01-20 16:32:21 +00:00
|
|
|
*/
|
|
|
|
|
void drm_warn_on_modeset_not_all_locked(struct drm_device *dev)
|
|
|
|
|
{
|
|
|
|
|
struct drm_crtc *crtc;
|
|
|
|
|
|
2013-05-02 07:43:05 +00:00
|
|
|
/* Locking is currently fubar in the panic handler. */
|
|
|
|
|
if (oops_in_progress)
|
|
|
|
|
return;
|
|
|
|
|
|
2013-01-20 16:32:21 +00:00
|
|
|
list_for_each_entry(crtc, &dev->mode_config.crtc_list, head)
|
2013-11-19 17:10:12 +00:00
|
|
|
WARN_ON(!drm_modeset_is_locked(&crtc->mutex));
|
2013-01-20 16:32:21 +00:00
|
|
|
|
2013-11-19 17:10:12 +00:00
|
|
|
WARN_ON(!drm_modeset_is_locked(&dev->mode_config.connection_mutex));
|
2013-01-20 16:32:21 +00:00
|
|
|
WARN_ON(!mutex_is_locked(&dev->mode_config.mutex));
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(drm_warn_on_modeset_not_all_locked);
|
|
|
|
|
|
2008-11-07 22:05:41 +00:00
|
|
|
/* Avoid boilerplate. I'm tired of typing. */
|
|
|
|
|
#define DRM_ENUM_NAME_FN(fnname, list) \
|
2013-06-07 15:43:07 +00:00
|
|
|
const char *fnname(int val) \
|
2008-11-07 22:05:41 +00:00
|
|
|
{ \
|
|
|
|
|
int i; \
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(list); i++) { \
|
|
|
|
|
if (list[i].type == val) \
|
|
|
|
|
return list[i].name; \
|
|
|
|
|
} \
|
|
|
|
|
return "(unknown)"; \
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Global properties
|
|
|
|
|
*/
|
2013-06-07 15:43:07 +00:00
|
|
|
static const struct drm_prop_enum_list drm_dpms_enum_list[] =
|
2008-11-07 22:05:41 +00:00
|
|
|
{ { DRM_MODE_DPMS_ON, "On" },
|
|
|
|
|
{ DRM_MODE_DPMS_STANDBY, "Standby" },
|
|
|
|
|
{ DRM_MODE_DPMS_SUSPEND, "Suspend" },
|
|
|
|
|
{ DRM_MODE_DPMS_OFF, "Off" }
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
DRM_ENUM_NAME_FN(drm_get_dpms_name, drm_dpms_enum_list)
|
|
|
|
|
|
2014-04-02 00:16:57 +00:00
|
|
|
static const struct drm_prop_enum_list drm_plane_type_enum_list[] =
|
|
|
|
|
{
|
|
|
|
|
{ DRM_PLANE_TYPE_OVERLAY, "Overlay" },
|
|
|
|
|
{ DRM_PLANE_TYPE_PRIMARY, "Primary" },
|
|
|
|
|
{ DRM_PLANE_TYPE_CURSOR, "Cursor" },
|
|
|
|
|
};
|
|
|
|
|
|
2008-11-07 22:05:41 +00:00
|
|
|
/*
|
|
|
|
|
* Optional properties
|
|
|
|
|
*/
|
2013-06-07 15:43:07 +00:00
|
|
|
static const struct drm_prop_enum_list drm_scaling_mode_enum_list[] =
|
2008-11-07 22:05:41 +00:00
|
|
|
{
|
2009-07-01 17:04:40 +00:00
|
|
|
{ DRM_MODE_SCALE_NONE, "None" },
|
|
|
|
|
{ DRM_MODE_SCALE_FULLSCREEN, "Full" },
|
|
|
|
|
{ DRM_MODE_SCALE_CENTER, "Center" },
|
|
|
|
|
{ DRM_MODE_SCALE_ASPECT, "Full aspect" },
|
2008-11-07 22:05:41 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Non-global properties, but "required" for certain connectors.
|
|
|
|
|
*/
|
2013-06-07 15:43:07 +00:00
|
|
|
static const struct drm_prop_enum_list drm_dvi_i_select_enum_list[] =
|
2008-11-07 22:05:41 +00:00
|
|
|
{
|
|
|
|
|
{ DRM_MODE_SUBCONNECTOR_Automatic, "Automatic" }, /* DVI-I and TV-out */
|
|
|
|
|
{ DRM_MODE_SUBCONNECTOR_DVID, "DVI-D" }, /* DVI-I */
|
|
|
|
|
{ DRM_MODE_SUBCONNECTOR_DVIA, "DVI-A" }, /* DVI-I */
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
DRM_ENUM_NAME_FN(drm_get_dvi_i_select_name, drm_dvi_i_select_enum_list)
|
|
|
|
|
|
2013-06-07 15:43:07 +00:00
|
|
|
static const struct drm_prop_enum_list drm_dvi_i_subconnector_enum_list[] =
|
2008-11-07 22:05:41 +00:00
|
|
|
{
|
|
|
|
|
{ DRM_MODE_SUBCONNECTOR_Unknown, "Unknown" }, /* DVI-I and TV-out */
|
|
|
|
|
{ DRM_MODE_SUBCONNECTOR_DVID, "DVI-D" }, /* DVI-I */
|
|
|
|
|
{ DRM_MODE_SUBCONNECTOR_DVIA, "DVI-A" }, /* DVI-I */
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
DRM_ENUM_NAME_FN(drm_get_dvi_i_subconnector_name,
|
|
|
|
|
drm_dvi_i_subconnector_enum_list)
|
|
|
|
|
|
2013-06-07 15:43:07 +00:00
|
|
|
static const struct drm_prop_enum_list drm_tv_select_enum_list[] =
|
2008-11-07 22:05:41 +00:00
|
|
|
{
|
|
|
|
|
{ DRM_MODE_SUBCONNECTOR_Automatic, "Automatic" }, /* DVI-I and TV-out */
|
|
|
|
|
{ DRM_MODE_SUBCONNECTOR_Composite, "Composite" }, /* TV-out */
|
|
|
|
|
{ DRM_MODE_SUBCONNECTOR_SVIDEO, "SVIDEO" }, /* TV-out */
|
|
|
|
|
{ DRM_MODE_SUBCONNECTOR_Component, "Component" }, /* TV-out */
|
2009-08-02 02:19:19 +00:00
|
|
|
{ DRM_MODE_SUBCONNECTOR_SCART, "SCART" }, /* TV-out */
|
2008-11-07 22:05:41 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
DRM_ENUM_NAME_FN(drm_get_tv_select_name, drm_tv_select_enum_list)
|
|
|
|
|
|
2013-06-07 15:43:07 +00:00
|
|
|
static const struct drm_prop_enum_list drm_tv_subconnector_enum_list[] =
|
2008-11-07 22:05:41 +00:00
|
|
|
{
|
|
|
|
|
{ DRM_MODE_SUBCONNECTOR_Unknown, "Unknown" }, /* DVI-I and TV-out */
|
|
|
|
|
{ DRM_MODE_SUBCONNECTOR_Composite, "Composite" }, /* TV-out */
|
|
|
|
|
{ DRM_MODE_SUBCONNECTOR_SVIDEO, "SVIDEO" }, /* TV-out */
|
|
|
|
|
{ DRM_MODE_SUBCONNECTOR_Component, "Component" }, /* TV-out */
|
2009-08-02 02:19:19 +00:00
|
|
|
{ DRM_MODE_SUBCONNECTOR_SCART, "SCART" }, /* TV-out */
|
2008-11-07 22:05:41 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
DRM_ENUM_NAME_FN(drm_get_tv_subconnector_name,
|
|
|
|
|
drm_tv_subconnector_enum_list)
|
|
|
|
|
|
2013-06-07 15:43:07 +00:00
|
|
|
static const struct drm_prop_enum_list drm_dirty_info_enum_list[] = {
|
2009-12-03 23:25:47 +00:00
|
|
|
{ DRM_MODE_DIRTY_OFF, "Off" },
|
|
|
|
|
{ DRM_MODE_DIRTY_ON, "On" },
|
|
|
|
|
{ DRM_MODE_DIRTY_ANNOTATE, "Annotate" },
|
|
|
|
|
};
|
|
|
|
|
|
2008-11-07 22:05:41 +00:00
|
|
|
struct drm_conn_prop_enum_list {
|
|
|
|
|
int type;
|
2013-06-07 15:43:07 +00:00
|
|
|
const char *name;
|
2013-08-08 02:34:48 +00:00
|
|
|
struct ida ida;
|
2008-11-07 22:05:41 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Connector and encoder types.
|
|
|
|
|
*/
|
|
|
|
|
static struct drm_conn_prop_enum_list drm_connector_enum_list[] =
|
2013-08-08 02:34:48 +00:00
|
|
|
{ { DRM_MODE_CONNECTOR_Unknown, "Unknown" },
|
|
|
|
|
{ DRM_MODE_CONNECTOR_VGA, "VGA" },
|
|
|
|
|
{ DRM_MODE_CONNECTOR_DVII, "DVI-I" },
|
|
|
|
|
{ DRM_MODE_CONNECTOR_DVID, "DVI-D" },
|
|
|
|
|
{ DRM_MODE_CONNECTOR_DVIA, "DVI-A" },
|
|
|
|
|
{ DRM_MODE_CONNECTOR_Composite, "Composite" },
|
|
|
|
|
{ DRM_MODE_CONNECTOR_SVIDEO, "SVIDEO" },
|
|
|
|
|
{ DRM_MODE_CONNECTOR_LVDS, "LVDS" },
|
|
|
|
|
{ DRM_MODE_CONNECTOR_Component, "Component" },
|
|
|
|
|
{ DRM_MODE_CONNECTOR_9PinDIN, "DIN" },
|
|
|
|
|
{ DRM_MODE_CONNECTOR_DisplayPort, "DP" },
|
|
|
|
|
{ DRM_MODE_CONNECTOR_HDMIA, "HDMI-A" },
|
|
|
|
|
{ DRM_MODE_CONNECTOR_HDMIB, "HDMI-B" },
|
|
|
|
|
{ DRM_MODE_CONNECTOR_TV, "TV" },
|
|
|
|
|
{ DRM_MODE_CONNECTOR_eDP, "eDP" },
|
|
|
|
|
{ DRM_MODE_CONNECTOR_VIRTUAL, "Virtual" },
|
2013-08-27 12:12:13 +00:00
|
|
|
{ DRM_MODE_CONNECTOR_DSI, "DSI" },
|
2008-11-07 22:05:41 +00:00
|
|
|
};
|
|
|
|
|
|
2013-06-07 15:43:07 +00:00
|
|
|
static const struct drm_prop_enum_list drm_encoder_enum_list[] =
|
2008-11-07 22:05:41 +00:00
|
|
|
{ { DRM_MODE_ENCODER_NONE, "None" },
|
|
|
|
|
{ DRM_MODE_ENCODER_DAC, "DAC" },
|
|
|
|
|
{ DRM_MODE_ENCODER_TMDS, "TMDS" },
|
|
|
|
|
{ DRM_MODE_ENCODER_LVDS, "LVDS" },
|
|
|
|
|
{ DRM_MODE_ENCODER_TVDAC, "TV" },
|
2011-10-22 08:36:19 +00:00
|
|
|
{ DRM_MODE_ENCODER_VIRTUAL, "Virtual" },
|
2013-08-27 12:12:13 +00:00
|
|
|
{ DRM_MODE_ENCODER_DSI, "DSI" },
|
2014-05-02 01:09:54 +00:00
|
|
|
{ DRM_MODE_ENCODER_DPMST, "DP MST" },
|
2008-11-07 22:05:41 +00:00
|
|
|
};
|
|
|
|
|
|
2014-02-10 23:32:44 +00:00
|
|
|
static const struct drm_prop_enum_list drm_subpixel_enum_list[] =
|
|
|
|
|
{
|
|
|
|
|
{ SubPixelUnknown, "Unknown" },
|
|
|
|
|
{ SubPixelHorizontalRGB, "Horizontal RGB" },
|
|
|
|
|
{ SubPixelHorizontalBGR, "Horizontal BGR" },
|
|
|
|
|
{ SubPixelVerticalRGB, "Vertical RGB" },
|
|
|
|
|
{ SubPixelVerticalBGR, "Vertical BGR" },
|
|
|
|
|
{ SubPixelNone, "None" },
|
|
|
|
|
};
|
|
|
|
|
|
2013-08-08 02:34:48 +00:00
|
|
|
void drm_connector_ida_init(void)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(drm_connector_enum_list); i++)
|
|
|
|
|
ida_init(&drm_connector_enum_list[i].ida);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void drm_connector_ida_destroy(void)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(drm_connector_enum_list); i++)
|
|
|
|
|
ida_destroy(&drm_connector_enum_list[i].ida);
|
|
|
|
|
}
|
|
|
|
|
|
2014-03-10 20:33:02 +00:00
|
|
|
/**
|
|
|
|
|
* drm_get_connector_status_name - return a string for connector status
|
|
|
|
|
* @status: connector status to compute name of
|
|
|
|
|
*
|
|
|
|
|
* In contrast to the other drm_get_*_name functions this one here returns a
|
|
|
|
|
* const pointer and hence is threadsafe.
|
|
|
|
|
*/
|
2013-06-07 15:43:07 +00:00
|
|
|
const char *drm_get_connector_status_name(enum drm_connector_status status)
|
2008-11-07 22:05:41 +00:00
|
|
|
{
|
|
|
|
|
if (status == connector_status_connected)
|
|
|
|
|
return "connected";
|
|
|
|
|
else if (status == connector_status_disconnected)
|
|
|
|
|
return "disconnected";
|
|
|
|
|
else
|
|
|
|
|
return "unknown";
|
|
|
|
|
}
|
2013-05-10 12:36:42 +00:00
|
|
|
EXPORT_SYMBOL(drm_get_connector_status_name);
|
2008-11-07 22:05:41 +00:00
|
|
|
|
2014-02-10 23:32:44 +00:00
|
|
|
/**
|
|
|
|
|
* drm_get_subpixel_order_name - return a string for a given subpixel enum
|
|
|
|
|
* @order: enum of subpixel_order
|
|
|
|
|
*
|
|
|
|
|
* Note you could abuse this and return something out of bounds, but that
|
|
|
|
|
* would be a caller error. No unscrubbed user data should make it here.
|
|
|
|
|
*/
|
|
|
|
|
const char *drm_get_subpixel_order_name(enum subpixel_order order)
|
|
|
|
|
{
|
|
|
|
|
return drm_subpixel_enum_list[order].name;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(drm_get_subpixel_order_name);
|
|
|
|
|
|
2013-06-10 08:15:10 +00:00
|
|
|
static char printable_char(int c)
|
|
|
|
|
{
|
|
|
|
|
return isascii(c) && isprint(c) ? c : '?';
|
|
|
|
|
}
|
|
|
|
|
|
2014-03-10 20:33:02 +00:00
|
|
|
/**
|
|
|
|
|
* drm_get_format_name - return a string for drm fourcc format
|
|
|
|
|
* @format: format to compute name of
|
|
|
|
|
*
|
|
|
|
|
* Note that the buffer used by this function is globally shared and owned by
|
|
|
|
|
* the function itself.
|
|
|
|
|
*
|
|
|
|
|
* FIXME: This isn't really multithreading safe.
|
|
|
|
|
*/
|
2013-06-07 15:43:07 +00:00
|
|
|
const char *drm_get_format_name(uint32_t format)
|
2013-06-10 08:15:10 +00:00
|
|
|
{
|
|
|
|
|
static char buf[32];
|
|
|
|
|
|
|
|
|
|
snprintf(buf, sizeof(buf),
|
|
|
|
|
"%c%c%c%c %s-endian (0x%08x)",
|
|
|
|
|
printable_char(format & 0xff),
|
|
|
|
|
printable_char((format >> 8) & 0xff),
|
|
|
|
|
printable_char((format >> 16) & 0xff),
|
|
|
|
|
printable_char((format >> 24) & 0x7f),
|
|
|
|
|
format & DRM_FORMAT_BIG_ENDIAN ? "big" : "little",
|
|
|
|
|
format);
|
|
|
|
|
|
|
|
|
|
return buf;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(drm_get_format_name);
|
|
|
|
|
|
2008-11-07 22:05:41 +00:00
|
|
|
/**
|
2012-12-01 23:09:18 +00:00
|
|
|
* drm_mode_object_get - allocate a new modeset identifier
|
2008-11-07 22:05:41 +00:00
|
|
|
* @dev: DRM device
|
2012-12-01 23:09:18 +00:00
|
|
|
* @obj: object pointer, used to generate unique ID
|
|
|
|
|
* @obj_type: object type
|
2008-11-07 22:05:41 +00:00
|
|
|
*
|
|
|
|
|
* Create a unique identifier based on @ptr in @dev's identifier space. Used
|
2014-03-10 20:33:02 +00:00
|
|
|
* for tracking modes, CRTCs and connectors. Note that despite the _get postfix
|
|
|
|
|
* modeset identifiers are _not_ reference counted. Hence don't use this for
|
|
|
|
|
* reference counted modeset objects like framebuffers.
|
2008-11-07 22:05:41 +00:00
|
|
|
*
|
2014-03-10 20:33:02 +00:00
|
|
|
* Returns:
|
2008-11-07 22:05:41 +00:00
|
|
|
* New unique (relative to other objects in @dev) integer identifier for the
|
|
|
|
|
* object.
|
|
|
|
|
*/
|
2014-01-23 14:35:24 +00:00
|
|
|
int drm_mode_object_get(struct drm_device *dev,
|
|
|
|
|
struct drm_mode_object *obj, uint32_t obj_type)
|
2008-11-07 22:05:41 +00:00
|
|
|
{
|
|
|
|
|
int ret;
|
|
|
|
|
|
2009-01-19 07:21:45 +00:00
|
|
|
mutex_lock(&dev->mode_config.idr_mutex);
|
2013-02-28 01:04:08 +00:00
|
|
|
ret = idr_alloc(&dev->mode_config.crtc_idr, obj, 1, 0, GFP_KERNEL);
|
|
|
|
|
if (ret >= 0) {
|
drm: revamp locking around fb creation/destruction
Well, at least step 1. The goal here is that framebuffer objects can
survive outside of the mode_config lock, with just a reference held
as protection. The first step to get there is to introduce a special
fb_lock which protects fb lookup, creation and destruction, to make
them appear atomic.
This new fb_lock can nest within the mode_config lock. But the idea is
(once the reference counting part is completed) that we only quickly
take that fb_lock to lookup a framebuffer and grab a reference,
without any other locks involved.
vmwgfx is the only driver which does framebuffer lookups itself, also
wrap those calls to drm_mode_object_find with the new lock.
Also protect the fb_list walking in i915 and omapdrm with the new lock.
As a slight complication there's also the list of user-created fbs
attached to the file private. The problem now is that at fclose() time
we need to walk that list, eventually do a modeset call to remove the
fb from active usage (and are required to be able to take the
mode_config lock), but in the end we need to grab the new fb_lock to
remove the fb from the list. The easiest solution is to add another
mutex to protect this per-file list.
Currently that new fbs_lock nests within the modeset locks and so
appears redudant. But later patches will switch around this sequence
so that taking the modeset locks in the fb destruction path is
optional in the fastpath. Ultimately the goal is that addfb and rmfb
do not require the mode_config lock, since otherwise they have the
potential to introduce stalls in the pageflip sequence of a compositor
(if the compositor e.g. switches to a fullscreen client or if it
enables a plane). But that requires a few more steps and hoops to jump
through.
Note that framebuffer creation/destruction is now double-protected -
once by the fb_lock and in parts by the idr_lock. The later would be
unnecessariy if framebuffers would have their own idr allocator. But
that's material for another patch (series).
v2: Properly initialize the fb->filp_head list in _init, otherwise the
newly added WARN to check whether the fb isn't on a fpriv list any
more will fail for driver-private objects.
v3: Fixup two error-case unlock bugs spotted by Richard Wilbur.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-10 20:19:18 +00:00
|
|
|
/*
|
|
|
|
|
* Set up the object linking under the protection of the idr
|
|
|
|
|
* lock so that other users can't see inconsistent state.
|
|
|
|
|
*/
|
2013-02-28 01:04:08 +00:00
|
|
|
obj->id = ret;
|
drm: revamp locking around fb creation/destruction
Well, at least step 1. The goal here is that framebuffer objects can
survive outside of the mode_config lock, with just a reference held
as protection. The first step to get there is to introduce a special
fb_lock which protects fb lookup, creation and destruction, to make
them appear atomic.
This new fb_lock can nest within the mode_config lock. But the idea is
(once the reference counting part is completed) that we only quickly
take that fb_lock to lookup a framebuffer and grab a reference,
without any other locks involved.
vmwgfx is the only driver which does framebuffer lookups itself, also
wrap those calls to drm_mode_object_find with the new lock.
Also protect the fb_list walking in i915 and omapdrm with the new lock.
As a slight complication there's also the list of user-created fbs
attached to the file private. The problem now is that at fclose() time
we need to walk that list, eventually do a modeset call to remove the
fb from active usage (and are required to be able to take the
mode_config lock), but in the end we need to grab the new fb_lock to
remove the fb from the list. The easiest solution is to add another
mutex to protect this per-file list.
Currently that new fbs_lock nests within the modeset locks and so
appears redudant. But later patches will switch around this sequence
so that taking the modeset locks in the fb destruction path is
optional in the fastpath. Ultimately the goal is that addfb and rmfb
do not require the mode_config lock, since otherwise they have the
potential to introduce stalls in the pageflip sequence of a compositor
(if the compositor e.g. switches to a fullscreen client or if it
enables a plane). But that requires a few more steps and hoops to jump
through.
Note that framebuffer creation/destruction is now double-protected -
once by the fb_lock and in parts by the idr_lock. The later would be
unnecessariy if framebuffers would have their own idr allocator. But
that's material for another patch (series).
v2: Properly initialize the fb->filp_head list in _init, otherwise the
newly added WARN to check whether the fb isn't on a fpriv list any
more will fail for driver-private objects.
v3: Fixup two error-case unlock bugs spotted by Richard Wilbur.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-10 20:19:18 +00:00
|
|
|
obj->type = obj_type;
|
|
|
|
|
}
|
2009-01-19 07:21:45 +00:00
|
|
|
mutex_unlock(&dev->mode_config.idr_mutex);
|
drm: revamp locking around fb creation/destruction
Well, at least step 1. The goal here is that framebuffer objects can
survive outside of the mode_config lock, with just a reference held
as protection. The first step to get there is to introduce a special
fb_lock which protects fb lookup, creation and destruction, to make
them appear atomic.
This new fb_lock can nest within the mode_config lock. But the idea is
(once the reference counting part is completed) that we only quickly
take that fb_lock to lookup a framebuffer and grab a reference,
without any other locks involved.
vmwgfx is the only driver which does framebuffer lookups itself, also
wrap those calls to drm_mode_object_find with the new lock.
Also protect the fb_list walking in i915 and omapdrm with the new lock.
As a slight complication there's also the list of user-created fbs
attached to the file private. The problem now is that at fclose() time
we need to walk that list, eventually do a modeset call to remove the
fb from active usage (and are required to be able to take the
mode_config lock), but in the end we need to grab the new fb_lock to
remove the fb from the list. The easiest solution is to add another
mutex to protect this per-file list.
Currently that new fbs_lock nests within the modeset locks and so
appears redudant. But later patches will switch around this sequence
so that taking the modeset locks in the fb destruction path is
optional in the fastpath. Ultimately the goal is that addfb and rmfb
do not require the mode_config lock, since otherwise they have the
potential to introduce stalls in the pageflip sequence of a compositor
(if the compositor e.g. switches to a fullscreen client or if it
enables a plane). But that requires a few more steps and hoops to jump
through.
Note that framebuffer creation/destruction is now double-protected -
once by the fb_lock and in parts by the idr_lock. The later would be
unnecessariy if framebuffers would have their own idr allocator. But
that's material for another patch (series).
v2: Properly initialize the fb->filp_head list in _init, otherwise the
newly added WARN to check whether the fb isn't on a fpriv list any
more will fail for driver-private objects.
v3: Fixup two error-case unlock bugs spotted by Richard Wilbur.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-10 20:19:18 +00:00
|
|
|
|
2013-02-28 01:04:08 +00:00
|
|
|
return ret < 0 ? ret : 0;
|
2008-11-07 22:05:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
2012-12-01 23:09:18 +00:00
|
|
|
* drm_mode_object_put - free a modeset identifer
|
2008-11-07 22:05:41 +00:00
|
|
|
* @dev: DRM device
|
2012-12-01 23:09:18 +00:00
|
|
|
* @object: object to free
|
2008-11-07 22:05:41 +00:00
|
|
|
*
|
2014-03-10 20:33:02 +00:00
|
|
|
* Free @id from @dev's unique identifier pool. Note that despite the _get
|
|
|
|
|
* postfix modeset identifiers are _not_ reference counted. Hence don't use this
|
|
|
|
|
* for reference counted modeset objects like framebuffers.
|
2008-11-07 22:05:41 +00:00
|
|
|
*/
|
2014-01-23 14:35:24 +00:00
|
|
|
void drm_mode_object_put(struct drm_device *dev,
|
|
|
|
|
struct drm_mode_object *object)
|
2008-11-07 22:05:41 +00:00
|
|
|
{
|
2009-01-19 07:21:45 +00:00
|
|
|
mutex_lock(&dev->mode_config.idr_mutex);
|
2008-11-07 22:05:41 +00:00
|
|
|
idr_remove(&dev->mode_config.crtc_idr, object->id);
|
2009-01-19 07:21:45 +00:00
|
|
|
mutex_unlock(&dev->mode_config.idr_mutex);
|
2008-11-07 22:05:41 +00:00
|
|
|
}
|
|
|
|
|
|
2014-05-30 15:37:03 +00:00
|
|
|
static struct drm_mode_object *_object_find(struct drm_device *dev,
|
|
|
|
|
uint32_t id, uint32_t type)
|
|
|
|
|
{
|
|
|
|
|
struct drm_mode_object *obj = NULL;
|
|
|
|
|
|
|
|
|
|
mutex_lock(&dev->mode_config.idr_mutex);
|
|
|
|
|
obj = idr_find(&dev->mode_config.crtc_idr, id);
|
|
|
|
|
if (!obj || (type != DRM_MODE_OBJECT_ANY && obj->type != type) ||
|
|
|
|
|
(obj->id != id))
|
|
|
|
|
obj = NULL;
|
|
|
|
|
mutex_unlock(&dev->mode_config.idr_mutex);
|
|
|
|
|
|
|
|
|
|
return obj;
|
|
|
|
|
}
|
|
|
|
|
|
2012-12-02 20:53:40 +00:00
|
|
|
/**
|
|
|
|
|
* drm_mode_object_find - look up a drm object with static lifetime
|
|
|
|
|
* @dev: drm device
|
|
|
|
|
* @id: id of the mode object
|
|
|
|
|
* @type: type of the mode object
|
|
|
|
|
*
|
|
|
|
|
* Note that framebuffers cannot be looked up with this functions - since those
|
2014-05-30 15:37:03 +00:00
|
|
|
* are reference counted, they need special treatment. Even with
|
|
|
|
|
* DRM_MODE_OBJECT_ANY (although that will simply return NULL
|
|
|
|
|
* rather than WARN_ON()).
|
2012-12-02 20:53:40 +00:00
|
|
|
*/
|
2009-09-15 20:57:31 +00:00
|
|
|
struct drm_mode_object *drm_mode_object_find(struct drm_device *dev,
|
|
|
|
|
uint32_t id, uint32_t type)
|
2008-11-07 22:05:41 +00:00
|
|
|
{
|
2009-01-19 07:21:45 +00:00
|
|
|
struct drm_mode_object *obj = NULL;
|
2008-11-07 22:05:41 +00:00
|
|
|
|
2012-12-02 20:53:40 +00:00
|
|
|
/* Framebuffers are reference counted and need their own lookup
|
|
|
|
|
* function.*/
|
|
|
|
|
WARN_ON(type == DRM_MODE_OBJECT_FB);
|
2014-05-30 15:37:03 +00:00
|
|
|
obj = _object_find(dev, id, type);
|
|
|
|
|
/* don't leak out unref'd fb's */
|
|
|
|
|
if (obj && (obj->type == DRM_MODE_OBJECT_FB))
|
2009-01-19 07:21:45 +00:00
|
|
|
obj = NULL;
|
2008-11-07 22:05:41 +00:00
|
|
|
return obj;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(drm_mode_object_find);
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* drm_framebuffer_init - initialize a framebuffer
|
|
|
|
|
* @dev: DRM device
|
2012-12-01 23:09:18 +00:00
|
|
|
* @fb: framebuffer to be initialized
|
|
|
|
|
* @funcs: ... with these functions
|
2008-11-07 22:05:41 +00:00
|
|
|
*
|
|
|
|
|
* Allocates an ID for the framebuffer's parent mode object, sets its mode
|
|
|
|
|
* functions & device file and adds it to the master fd list.
|
|
|
|
|
*
|
drm: revamp locking around fb creation/destruction
Well, at least step 1. The goal here is that framebuffer objects can
survive outside of the mode_config lock, with just a reference held
as protection. The first step to get there is to introduce a special
fb_lock which protects fb lookup, creation and destruction, to make
them appear atomic.
This new fb_lock can nest within the mode_config lock. But the idea is
(once the reference counting part is completed) that we only quickly
take that fb_lock to lookup a framebuffer and grab a reference,
without any other locks involved.
vmwgfx is the only driver which does framebuffer lookups itself, also
wrap those calls to drm_mode_object_find with the new lock.
Also protect the fb_list walking in i915 and omapdrm with the new lock.
As a slight complication there's also the list of user-created fbs
attached to the file private. The problem now is that at fclose() time
we need to walk that list, eventually do a modeset call to remove the
fb from active usage (and are required to be able to take the
mode_config lock), but in the end we need to grab the new fb_lock to
remove the fb from the list. The easiest solution is to add another
mutex to protect this per-file list.
Currently that new fbs_lock nests within the modeset locks and so
appears redudant. But later patches will switch around this sequence
so that taking the modeset locks in the fb destruction path is
optional in the fastpath. Ultimately the goal is that addfb and rmfb
do not require the mode_config lock, since otherwise they have the
potential to introduce stalls in the pageflip sequence of a compositor
(if the compositor e.g. switches to a fullscreen client or if it
enables a plane). But that requires a few more steps and hoops to jump
through.
Note that framebuffer creation/destruction is now double-protected -
once by the fb_lock and in parts by the idr_lock. The later would be
unnecessariy if framebuffers would have their own idr allocator. But
that's material for another patch (series).
v2: Properly initialize the fb->filp_head list in _init, otherwise the
newly added WARN to check whether the fb isn't on a fpriv list any
more will fail for driver-private objects.
v3: Fixup two error-case unlock bugs spotted by Richard Wilbur.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-10 20:19:18 +00:00
|
|
|
* IMPORTANT:
|
|
|
|
|
* This functions publishes the fb and makes it available for concurrent access
|
|
|
|
|
* by other users. Which means by this point the fb _must_ be fully set up -
|
|
|
|
|
* since all the fb attributes are invariant over its lifetime, no further
|
|
|
|
|
* locking but only correct reference counting is required.
|
|
|
|
|
*
|
2014-03-10 20:33:02 +00:00
|
|
|
* Returns:
|
tree-wide: fix assorted typos all over the place
That is "success", "unknown", "through", "performance", "[re|un]mapping"
, "access", "default", "reasonable", "[con]currently", "temperature"
, "channel", "[un]used", "application", "example","hierarchy", "therefore"
, "[over|under]flow", "contiguous", "threshold", "enough" and others.
Signed-off-by: André Goddard Rosa <andre.goddard@gmail.com>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
2009-11-14 15:09:05 +00:00
|
|
|
* Zero on success, error code on failure.
|
2008-11-07 22:05:41 +00:00
|
|
|
*/
|
|
|
|
|
int drm_framebuffer_init(struct drm_device *dev, struct drm_framebuffer *fb,
|
|
|
|
|
const struct drm_framebuffer_funcs *funcs)
|
|
|
|
|
{
|
|
|
|
|
int ret;
|
|
|
|
|
|
drm: revamp locking around fb creation/destruction
Well, at least step 1. The goal here is that framebuffer objects can
survive outside of the mode_config lock, with just a reference held
as protection. The first step to get there is to introduce a special
fb_lock which protects fb lookup, creation and destruction, to make
them appear atomic.
This new fb_lock can nest within the mode_config lock. But the idea is
(once the reference counting part is completed) that we only quickly
take that fb_lock to lookup a framebuffer and grab a reference,
without any other locks involved.
vmwgfx is the only driver which does framebuffer lookups itself, also
wrap those calls to drm_mode_object_find with the new lock.
Also protect the fb_list walking in i915 and omapdrm with the new lock.
As a slight complication there's also the list of user-created fbs
attached to the file private. The problem now is that at fclose() time
we need to walk that list, eventually do a modeset call to remove the
fb from active usage (and are required to be able to take the
mode_config lock), but in the end we need to grab the new fb_lock to
remove the fb from the list. The easiest solution is to add another
mutex to protect this per-file list.
Currently that new fbs_lock nests within the modeset locks and so
appears redudant. But later patches will switch around this sequence
so that taking the modeset locks in the fb destruction path is
optional in the fastpath. Ultimately the goal is that addfb and rmfb
do not require the mode_config lock, since otherwise they have the
potential to introduce stalls in the pageflip sequence of a compositor
(if the compositor e.g. switches to a fullscreen client or if it
enables a plane). But that requires a few more steps and hoops to jump
through.
Note that framebuffer creation/destruction is now double-protected -
once by the fb_lock and in parts by the idr_lock. The later would be
unnecessariy if framebuffers would have their own idr allocator. But
that's material for another patch (series).
v2: Properly initialize the fb->filp_head list in _init, otherwise the
newly added WARN to check whether the fb isn't on a fpriv list any
more will fail for driver-private objects.
v3: Fixup two error-case unlock bugs spotted by Richard Wilbur.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-10 20:19:18 +00:00
|
|
|
mutex_lock(&dev->mode_config.fb_lock);
|
2012-09-05 21:48:38 +00:00
|
|
|
kref_init(&fb->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-10 20:19:18 +00:00
|
|
|
INIT_LIST_HEAD(&fb->filp_head);
|
|
|
|
|
fb->dev = dev;
|
|
|
|
|
fb->funcs = funcs;
|
2012-09-05 21:48:38 +00:00
|
|
|
|
2008-11-07 22:05:41 +00:00
|
|
|
ret = drm_mode_object_get(dev, &fb->base, DRM_MODE_OBJECT_FB);
|
2012-03-13 10:35:48 +00:00
|
|
|
if (ret)
|
drm: revamp locking around fb creation/destruction
Well, at least step 1. The goal here is that framebuffer objects can
survive outside of the mode_config lock, with just a reference held
as protection. The first step to get there is to introduce a special
fb_lock which protects fb lookup, creation and destruction, to make
them appear atomic.
This new fb_lock can nest within the mode_config lock. But the idea is
(once the reference counting part is completed) that we only quickly
take that fb_lock to lookup a framebuffer and grab a reference,
without any other locks involved.
vmwgfx is the only driver which does framebuffer lookups itself, also
wrap those calls to drm_mode_object_find with the new lock.
Also protect the fb_list walking in i915 and omapdrm with the new lock.
As a slight complication there's also the list of user-created fbs
attached to the file private. The problem now is that at fclose() time
we need to walk that list, eventually do a modeset call to remove the
fb from active usage (and are required to be able to take the
mode_config lock), but in the end we need to grab the new fb_lock to
remove the fb from the list. The easiest solution is to add another
mutex to protect this per-file list.
Currently that new fbs_lock nests within the modeset locks and so
appears redudant. But later patches will switch around this sequence
so that taking the modeset locks in the fb destruction path is
optional in the fastpath. Ultimately the goal is that addfb and rmfb
do not require the mode_config lock, since otherwise they have the
potential to introduce stalls in the pageflip sequence of a compositor
(if the compositor e.g. switches to a fullscreen client or if it
enables a plane). But that requires a few more steps and hoops to jump
through.
Note that framebuffer creation/destruction is now double-protected -
once by the fb_lock and in parts by the idr_lock. The later would be
unnecessariy if framebuffers would have their own idr allocator. But
that's material for another patch (series).
v2: Properly initialize the fb->filp_head list in _init, otherwise the
newly added WARN to check whether the fb isn't on a fpriv list any
more will fail for driver-private objects.
v3: Fixup two error-case unlock bugs spotted by Richard Wilbur.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-10 20:19:18 +00:00
|
|
|
goto out;
|
2008-11-07 22:05:41 +00:00
|
|
|
|
drm: reference framebuffers which are on the idr
Since otherwise looking and reference-counting around
drm_framebuffer_lookup will be an unmanageable mess. With this change,
an object can either be found in the idr and will stay around once we
incremented the reference counter. Or it will be gone for good and
can't be looked up using its id any more.
Atomicity is guaranteed by the dev->mode_config.fb_lock. The
newly-introduce fpriv->fbs_lock looks a bit redundant, but the next
patch will shuffle the locking order between these two locks and all
the modeset locks taken in modeset_lock_all, so we'll need it.
Also, since userspace could do really funky stuff and race e.g. a
getresources with an rmfb, we need to make sure that the kernel
doesn't fall over trying to look-up an inexistent fb, or causing
confusion by having two fbs around with the same id. Simply reset the
framebuffer id to 0, which marks it as reaped. Any lookups of that id
will fail, so the object is really gone for good from userspace's pov.
Note that we still need to protect the "remove framebuffer from all
use-cases" and the final unreference with the modeset-lock, since most
framebuffer use-sites don't implement proper reference counting yet.
We can only lift this once _all_ users are converted.
With this change, two references are held on alife, but unused
framebuffers:
- The reference for the idr lookup, created in this patch.
- For user-created framebuffers the fpriv->fbs reference, for
driver-private fbs the driver is supposed to hold it's own last
reference.
Note that the dev->mode_config.fb_list itself does _not_ hold a
reference onto the framebuffers (this list is essentially only used
for debugfs files). Hence if there's anything left there when the
driver has cleaned up all it's modeset resources, this is a ref-leak.
WARN about it.
Now we only need to fix up all other places to properly reference
count framebuffers.
v2: Fix spelling fail in a comment spotted by Rob Clark.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-10 20:16:05 +00:00
|
|
|
/* Grab the idr reference. */
|
|
|
|
|
drm_framebuffer_reference(fb);
|
|
|
|
|
|
2008-11-07 22:05:41 +00:00
|
|
|
dev->mode_config.num_fb++;
|
|
|
|
|
list_add(&fb->head, &dev->mode_config.fb_list);
|
drm: revamp locking around fb creation/destruction
Well, at least step 1. The goal here is that framebuffer objects can
survive outside of the mode_config lock, with just a reference held
as protection. The first step to get there is to introduce a special
fb_lock which protects fb lookup, creation and destruction, to make
them appear atomic.
This new fb_lock can nest within the mode_config lock. But the idea is
(once the reference counting part is completed) that we only quickly
take that fb_lock to lookup a framebuffer and grab a reference,
without any other locks involved.
vmwgfx is the only driver which does framebuffer lookups itself, also
wrap those calls to drm_mode_object_find with the new lock.
Also protect the fb_list walking in i915 and omapdrm with the new lock.
As a slight complication there's also the list of user-created fbs
attached to the file private. The problem now is that at fclose() time
we need to walk that list, eventually do a modeset call to remove the
fb from active usage (and are required to be able to take the
mode_config lock), but in the end we need to grab the new fb_lock to
remove the fb from the list. The easiest solution is to add another
mutex to protect this per-file list.
Currently that new fbs_lock nests within the modeset locks and so
appears redudant. But later patches will switch around this sequence
so that taking the modeset locks in the fb destruction path is
optional in the fastpath. Ultimately the goal is that addfb and rmfb
do not require the mode_config lock, since otherwise they have the
potential to introduce stalls in the pageflip sequence of a compositor
(if the compositor e.g. switches to a fullscreen client or if it
enables a plane). But that requires a few more steps and hoops to jump
through.
Note that framebuffer creation/destruction is now double-protected -
once by the fb_lock and in parts by the idr_lock. The later would be
unnecessariy if framebuffers would have their own idr allocator. But
that's material for another patch (series).
v2: Properly initialize the fb->filp_head list in _init, otherwise the
newly added WARN to check whether the fb isn't on a fpriv list any
more will fail for driver-private objects.
v3: Fixup two error-case unlock bugs spotted by Richard Wilbur.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-10 20:19:18 +00:00
|
|
|
out:
|
|
|
|
|
mutex_unlock(&dev->mode_config.fb_lock);
|
2008-11-07 22:05:41 +00:00
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(drm_framebuffer_init);
|
|
|
|
|
|
2012-09-05 21:48:38 +00:00
|
|
|
static void drm_framebuffer_free(struct kref *kref)
|
|
|
|
|
{
|
|
|
|
|
struct drm_framebuffer *fb =
|
|
|
|
|
container_of(kref, struct drm_framebuffer, refcount);
|
|
|
|
|
fb->funcs->destroy(fb);
|
|
|
|
|
}
|
|
|
|
|
|
drm: reference framebuffers which are on the idr
Since otherwise looking and reference-counting around
drm_framebuffer_lookup will be an unmanageable mess. With this change,
an object can either be found in the idr and will stay around once we
incremented the reference counter. Or it will be gone for good and
can't be looked up using its id any more.
Atomicity is guaranteed by the dev->mode_config.fb_lock. The
newly-introduce fpriv->fbs_lock looks a bit redundant, but the next
patch will shuffle the locking order between these two locks and all
the modeset locks taken in modeset_lock_all, so we'll need it.
Also, since userspace could do really funky stuff and race e.g. a
getresources with an rmfb, we need to make sure that the kernel
doesn't fall over trying to look-up an inexistent fb, or causing
confusion by having two fbs around with the same id. Simply reset the
framebuffer id to 0, which marks it as reaped. Any lookups of that id
will fail, so the object is really gone for good from userspace's pov.
Note that we still need to protect the "remove framebuffer from all
use-cases" and the final unreference with the modeset-lock, since most
framebuffer use-sites don't implement proper reference counting yet.
We can only lift this once _all_ users are converted.
With this change, two references are held on alife, but unused
framebuffers:
- The reference for the idr lookup, created in this patch.
- For user-created framebuffers the fpriv->fbs reference, for
driver-private fbs the driver is supposed to hold it's own last
reference.
Note that the dev->mode_config.fb_list itself does _not_ hold a
reference onto the framebuffers (this list is essentially only used
for debugfs files). Hence if there's anything left there when the
driver has cleaned up all it's modeset resources, this is a ref-leak.
WARN about it.
Now we only need to fix up all other places to properly reference
count framebuffers.
v2: Fix spelling fail in a comment spotted by Rob Clark.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-10 20:16:05 +00:00
|
|
|
static struct drm_framebuffer *__drm_framebuffer_lookup(struct drm_device *dev,
|
|
|
|
|
uint32_t id)
|
|
|
|
|
{
|
|
|
|
|
struct drm_mode_object *obj = NULL;
|
|
|
|
|
struct drm_framebuffer *fb;
|
|
|
|
|
|
|
|
|
|
mutex_lock(&dev->mode_config.idr_mutex);
|
|
|
|
|
obj = idr_find(&dev->mode_config.crtc_idr, id);
|
|
|
|
|
if (!obj || (obj->type != DRM_MODE_OBJECT_FB) || (obj->id != id))
|
|
|
|
|
fb = NULL;
|
|
|
|
|
else
|
|
|
|
|
fb = obj_to_fb(obj);
|
|
|
|
|
mutex_unlock(&dev->mode_config.idr_mutex);
|
|
|
|
|
|
|
|
|
|
return fb;
|
|
|
|
|
}
|
|
|
|
|
|
2012-12-02 20:53:40 +00:00
|
|
|
/**
|
|
|
|
|
* drm_framebuffer_lookup - look up a drm framebuffer and grab a reference
|
|
|
|
|
* @dev: drm device
|
|
|
|
|
* @id: id of the fb object
|
|
|
|
|
*
|
|
|
|
|
* If successful, this grabs an additional reference to the framebuffer -
|
|
|
|
|
* callers need to make sure to eventually unreference the returned framebuffer
|
2014-03-10 20:33:02 +00:00
|
|
|
* again, using @drm_framebuffer_unreference.
|
2012-12-02 20:53:40 +00:00
|
|
|
*/
|
|
|
|
|
struct drm_framebuffer *drm_framebuffer_lookup(struct drm_device *dev,
|
|
|
|
|
uint32_t id)
|
|
|
|
|
{
|
|
|
|
|
struct drm_framebuffer *fb;
|
|
|
|
|
|
|
|
|
|
mutex_lock(&dev->mode_config.fb_lock);
|
drm: reference framebuffers which are on the idr
Since otherwise looking and reference-counting around
drm_framebuffer_lookup will be an unmanageable mess. With this change,
an object can either be found in the idr and will stay around once we
incremented the reference counter. Or it will be gone for good and
can't be looked up using its id any more.
Atomicity is guaranteed by the dev->mode_config.fb_lock. The
newly-introduce fpriv->fbs_lock looks a bit redundant, but the next
patch will shuffle the locking order between these two locks and all
the modeset locks taken in modeset_lock_all, so we'll need it.
Also, since userspace could do really funky stuff and race e.g. a
getresources with an rmfb, we need to make sure that the kernel
doesn't fall over trying to look-up an inexistent fb, or causing
confusion by having two fbs around with the same id. Simply reset the
framebuffer id to 0, which marks it as reaped. Any lookups of that id
will fail, so the object is really gone for good from userspace's pov.
Note that we still need to protect the "remove framebuffer from all
use-cases" and the final unreference with the modeset-lock, since most
framebuffer use-sites don't implement proper reference counting yet.
We can only lift this once _all_ users are converted.
With this change, two references are held on alife, but unused
framebuffers:
- The reference for the idr lookup, created in this patch.
- For user-created framebuffers the fpriv->fbs reference, for
driver-private fbs the driver is supposed to hold it's own last
reference.
Note that the dev->mode_config.fb_list itself does _not_ hold a
reference onto the framebuffers (this list is essentially only used
for debugfs files). Hence if there's anything left there when the
driver has cleaned up all it's modeset resources, this is a ref-leak.
WARN about it.
Now we only need to fix up all other places to properly reference
count framebuffers.
v2: Fix spelling fail in a comment spotted by Rob Clark.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-10 20:16:05 +00:00
|
|
|
fb = __drm_framebuffer_lookup(dev, id);
|
2012-12-02 20:53:40 +00:00
|
|
|
if (fb)
|
2013-04-10 08:59:39 +00:00
|
|
|
drm_framebuffer_reference(fb);
|
2012-12-02 20:53:40 +00:00
|
|
|
mutex_unlock(&dev->mode_config.fb_lock);
|
|
|
|
|
|
|
|
|
|
return fb;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(drm_framebuffer_lookup);
|
|
|
|
|
|
2012-09-05 21:48:38 +00:00
|
|
|
/**
|
|
|
|
|
* drm_framebuffer_unreference - unref a framebuffer
|
2012-12-01 23:09:18 +00:00
|
|
|
* @fb: framebuffer to unref
|
|
|
|
|
*
|
|
|
|
|
* This functions decrements the fb's refcount and frees it if it drops to zero.
|
2012-09-05 21:48:38 +00:00
|
|
|
*/
|
|
|
|
|
void drm_framebuffer_unreference(struct drm_framebuffer *fb)
|
|
|
|
|
{
|
2014-03-18 14:07:08 +00:00
|
|
|
DRM_DEBUG("%p: FB ID: %d (%d)\n", fb, fb->base.id, atomic_read(&fb->refcount.refcount));
|
2012-09-05 21:48:38 +00:00
|
|
|
kref_put(&fb->refcount, drm_framebuffer_free);
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(drm_framebuffer_unreference);
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* drm_framebuffer_reference - incr the fb refcnt
|
2012-12-01 23:09:18 +00:00
|
|
|
* @fb: framebuffer
|
2014-03-10 20:33:02 +00:00
|
|
|
*
|
|
|
|
|
* This functions increments the fb's refcount.
|
2012-09-05 21:48:38 +00:00
|
|
|
*/
|
|
|
|
|
void drm_framebuffer_reference(struct drm_framebuffer *fb)
|
|
|
|
|
{
|
2014-03-18 14:07:08 +00:00
|
|
|
DRM_DEBUG("%p: FB ID: %d (%d)\n", fb, fb->base.id, atomic_read(&fb->refcount.refcount));
|
2012-09-05 21:48:38 +00:00
|
|
|
kref_get(&fb->refcount);
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(drm_framebuffer_reference);
|
|
|
|
|
|
drm: reference framebuffers which are on the idr
Since otherwise looking and reference-counting around
drm_framebuffer_lookup will be an unmanageable mess. With this change,
an object can either be found in the idr and will stay around once we
incremented the reference counter. Or it will be gone for good and
can't be looked up using its id any more.
Atomicity is guaranteed by the dev->mode_config.fb_lock. The
newly-introduce fpriv->fbs_lock looks a bit redundant, but the next
patch will shuffle the locking order between these two locks and all
the modeset locks taken in modeset_lock_all, so we'll need it.
Also, since userspace could do really funky stuff and race e.g. a
getresources with an rmfb, we need to make sure that the kernel
doesn't fall over trying to look-up an inexistent fb, or causing
confusion by having two fbs around with the same id. Simply reset the
framebuffer id to 0, which marks it as reaped. Any lookups of that id
will fail, so the object is really gone for good from userspace's pov.
Note that we still need to protect the "remove framebuffer from all
use-cases" and the final unreference with the modeset-lock, since most
framebuffer use-sites don't implement proper reference counting yet.
We can only lift this once _all_ users are converted.
With this change, two references are held on alife, but unused
framebuffers:
- The reference for the idr lookup, created in this patch.
- For user-created framebuffers the fpriv->fbs reference, for
driver-private fbs the driver is supposed to hold it's own last
reference.
Note that the dev->mode_config.fb_list itself does _not_ hold a
reference onto the framebuffers (this list is essentially only used
for debugfs files). Hence if there's anything left there when the
driver has cleaned up all it's modeset resources, this is a ref-leak.
WARN about it.
Now we only need to fix up all other places to properly reference
count framebuffers.
v2: Fix spelling fail in a comment spotted by Rob Clark.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-10 20:16:05 +00:00
|
|
|
static void drm_framebuffer_free_bug(struct kref *kref)
|
|
|
|
|
{
|
|
|
|
|
BUG();
|
|
|
|
|
}
|
|
|
|
|
|
2012-12-10 23:59:24 +00:00
|
|
|
static void __drm_framebuffer_unreference(struct drm_framebuffer *fb)
|
|
|
|
|
{
|
2014-03-18 14:07:08 +00:00
|
|
|
DRM_DEBUG("%p: FB ID: %d (%d)\n", fb, fb->base.id, atomic_read(&fb->refcount.refcount));
|
2012-12-10 23:59:24 +00:00
|
|
|
kref_put(&fb->refcount, drm_framebuffer_free_bug);
|
|
|
|
|
}
|
|
|
|
|
|
drm: reference framebuffers which are on the idr
Since otherwise looking and reference-counting around
drm_framebuffer_lookup will be an unmanageable mess. With this change,
an object can either be found in the idr and will stay around once we
incremented the reference counter. Or it will be gone for good and
can't be looked up using its id any more.
Atomicity is guaranteed by the dev->mode_config.fb_lock. The
newly-introduce fpriv->fbs_lock looks a bit redundant, but the next
patch will shuffle the locking order between these two locks and all
the modeset locks taken in modeset_lock_all, so we'll need it.
Also, since userspace could do really funky stuff and race e.g. a
getresources with an rmfb, we need to make sure that the kernel
doesn't fall over trying to look-up an inexistent fb, or causing
confusion by having two fbs around with the same id. Simply reset the
framebuffer id to 0, which marks it as reaped. Any lookups of that id
will fail, so the object is really gone for good from userspace's pov.
Note that we still need to protect the "remove framebuffer from all
use-cases" and the final unreference with the modeset-lock, since most
framebuffer use-sites don't implement proper reference counting yet.
We can only lift this once _all_ users are converted.
With this change, two references are held on alife, but unused
framebuffers:
- The reference for the idr lookup, created in this patch.
- For user-created framebuffers the fpriv->fbs reference, for
driver-private fbs the driver is supposed to hold it's own last
reference.
Note that the dev->mode_config.fb_list itself does _not_ hold a
reference onto the framebuffers (this list is essentially only used
for debugfs files). Hence if there's anything left there when the
driver has cleaned up all it's modeset resources, this is a ref-leak.
WARN about it.
Now we only need to fix up all other places to properly reference
count framebuffers.
v2: Fix spelling fail in a comment spotted by Rob Clark.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-10 20:16:05 +00:00
|
|
|
/* dev->mode_config.fb_lock must be held! */
|
|
|
|
|
static void __drm_framebuffer_unregister(struct drm_device *dev,
|
|
|
|
|
struct drm_framebuffer *fb)
|
|
|
|
|
{
|
|
|
|
|
mutex_lock(&dev->mode_config.idr_mutex);
|
|
|
|
|
idr_remove(&dev->mode_config.crtc_idr, fb->base.id);
|
|
|
|
|
mutex_unlock(&dev->mode_config.idr_mutex);
|
|
|
|
|
|
|
|
|
|
fb->base.id = 0;
|
|
|
|
|
|
2012-12-10 23:59:24 +00:00
|
|
|
__drm_framebuffer_unreference(fb);
|
drm: reference framebuffers which are on the idr
Since otherwise looking and reference-counting around
drm_framebuffer_lookup will be an unmanageable mess. With this change,
an object can either be found in the idr and will stay around once we
incremented the reference counter. Or it will be gone for good and
can't be looked up using its id any more.
Atomicity is guaranteed by the dev->mode_config.fb_lock. The
newly-introduce fpriv->fbs_lock looks a bit redundant, but the next
patch will shuffle the locking order between these two locks and all
the modeset locks taken in modeset_lock_all, so we'll need it.
Also, since userspace could do really funky stuff and race e.g. a
getresources with an rmfb, we need to make sure that the kernel
doesn't fall over trying to look-up an inexistent fb, or causing
confusion by having two fbs around with the same id. Simply reset the
framebuffer id to 0, which marks it as reaped. Any lookups of that id
will fail, so the object is really gone for good from userspace's pov.
Note that we still need to protect the "remove framebuffer from all
use-cases" and the final unreference with the modeset-lock, since most
framebuffer use-sites don't implement proper reference counting yet.
We can only lift this once _all_ users are converted.
With this change, two references are held on alife, but unused
framebuffers:
- The reference for the idr lookup, created in this patch.
- For user-created framebuffers the fpriv->fbs reference, for
driver-private fbs the driver is supposed to hold it's own last
reference.
Note that the dev->mode_config.fb_list itself does _not_ hold a
reference onto the framebuffers (this list is essentially only used
for debugfs files). Hence if there's anything left there when the
driver has cleaned up all it's modeset resources, this is a ref-leak.
WARN about it.
Now we only need to fix up all other places to properly reference
count framebuffers.
v2: Fix spelling fail in a comment spotted by Rob Clark.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-10 20:16:05 +00:00
|
|
|
}
|
|
|
|
|
|
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-10 19:42:17 +00:00
|
|
|
/**
|
|
|
|
|
* drm_framebuffer_unregister_private - unregister a private fb from the lookup idr
|
|
|
|
|
* @fb: fb to unregister
|
|
|
|
|
*
|
|
|
|
|
* Drivers need to call this when cleaning up driver-private framebuffers, e.g.
|
|
|
|
|
* those used for fbdev. Note that the caller must hold a reference of it's own,
|
|
|
|
|
* i.e. the object may not be destroyed through this call (since it'll lead to a
|
|
|
|
|
* locking inversion).
|
|
|
|
|
*/
|
|
|
|
|
void drm_framebuffer_unregister_private(struct drm_framebuffer *fb)
|
|
|
|
|
{
|
drm: reference framebuffers which are on the idr
Since otherwise looking and reference-counting around
drm_framebuffer_lookup will be an unmanageable mess. With this change,
an object can either be found in the idr and will stay around once we
incremented the reference counter. Or it will be gone for good and
can't be looked up using its id any more.
Atomicity is guaranteed by the dev->mode_config.fb_lock. The
newly-introduce fpriv->fbs_lock looks a bit redundant, but the next
patch will shuffle the locking order between these two locks and all
the modeset locks taken in modeset_lock_all, so we'll need it.
Also, since userspace could do really funky stuff and race e.g. a
getresources with an rmfb, we need to make sure that the kernel
doesn't fall over trying to look-up an inexistent fb, or causing
confusion by having two fbs around with the same id. Simply reset the
framebuffer id to 0, which marks it as reaped. Any lookups of that id
will fail, so the object is really gone for good from userspace's pov.
Note that we still need to protect the "remove framebuffer from all
use-cases" and the final unreference with the modeset-lock, since most
framebuffer use-sites don't implement proper reference counting yet.
We can only lift this once _all_ users are converted.
With this change, two references are held on alife, but unused
framebuffers:
- The reference for the idr lookup, created in this patch.
- For user-created framebuffers the fpriv->fbs reference, for
driver-private fbs the driver is supposed to hold it's own last
reference.
Note that the dev->mode_config.fb_list itself does _not_ hold a
reference onto the framebuffers (this list is essentially only used
for debugfs files). Hence if there's anything left there when the
driver has cleaned up all it's modeset resources, this is a ref-leak.
WARN about it.
Now we only need to fix up all other places to properly reference
count framebuffers.
v2: Fix spelling fail in a comment spotted by Rob Clark.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-10 20:16:05 +00:00
|
|
|
struct drm_device *dev = fb->dev;
|
|
|
|
|
|
|
|
|
|
mutex_lock(&dev->mode_config.fb_lock);
|
|
|
|
|
/* Mark fb as reaped and drop idr ref. */
|
|
|
|
|
__drm_framebuffer_unregister(dev, fb);
|
|
|
|
|
mutex_unlock(&dev->mode_config.fb_lock);
|
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-10 19:42:17 +00:00
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(drm_framebuffer_unregister_private);
|
|
|
|
|
|
2008-11-07 22:05:41 +00:00
|
|
|
/**
|
|
|
|
|
* drm_framebuffer_cleanup - remove a framebuffer object
|
|
|
|
|
* @fb: framebuffer to remove
|
|
|
|
|
*
|
2014-03-10 20:33:02 +00:00
|
|
|
* Cleanup framebuffer. This function is intended to be used from the drivers
|
|
|
|
|
* ->destroy callback. It can also be used to clean up driver private
|
|
|
|
|
* framebuffers embedded into a larger structure.
|
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-10 19:42:17 +00:00
|
|
|
*
|
|
|
|
|
* Note that this function does not remove the fb from active usuage - if it is
|
|
|
|
|
* still used anywhere, hilarity can ensue since userspace could call getfb on
|
|
|
|
|
* the id and get back -EINVAL. Obviously no concern at driver unload time.
|
|
|
|
|
*
|
|
|
|
|
* Also, the framebuffer will not be removed from the lookup idr - for
|
|
|
|
|
* user-created framebuffers this will happen in in the rmfb ioctl. For
|
|
|
|
|
* driver-private objects (e.g. for fbdev) drivers need to explicitly call
|
|
|
|
|
* drm_framebuffer_unregister_private.
|
2008-11-07 22:05:41 +00:00
|
|
|
*/
|
|
|
|
|
void drm_framebuffer_cleanup(struct drm_framebuffer *fb)
|
2012-09-05 21:48:38 +00:00
|
|
|
{
|
|
|
|
|
struct drm_device *dev = fb->dev;
|
drm: review locking rules in drm_crtc.c
- config_cleanup was confused: It claimed that callers need to hold
the modeset lock, but the connector|encoder_cleanup helpers grabbed
that themselves (note that crtc_cleanup did _not_ grab the modeset
lock). Which resulted in all drivers _not_ hodling the lock. Since
this is for single-threaded cleanup code, drop the requirement from
docs and also drop the lock_grabbing from all _cleanup functions.
- Kill the LOCKING section in the doctype, since clearly we're not
good enough to keep them up-to-date. And misleading locking
documentation is worse than useless (see e.g. the comment in the
vmgfx driver about the cleanup mess). And since for most functions
the very first line either grabs the lock or has a WARN_ON(!locked)
the documentation doesn't really add anything.
- Instead put in some effort into explaining the only two special
cases a bit better: config_init and config_cleanup are both called
from single-threaded setup/teardown code, so don't do any locking.
It's the driver's job though to enforce this.
- Where lacking, add a WARN_ON(!is_locked). Not many places though,
since locking around fbdev setup/teardown is through-roughly screwed
up, and so will break almost every single WARN annotation I've tried
to add.
- Add a drm_modeset_is_locked helper - the Grate Modset Locking Rework
will use the compiler to assist in the big reorg by renaming the
mode lock, so start encapsulating things. Unfortunately this ended
up in the "wrong" header file since it needs the definition of
struct drm_device.
v2: Drop most WARNS again - we hit them all over the place, mostly in
the setup and teardown sequences. And trying to fix it up leads to
nice deadlocks, since the locking in the setup code is really
inconsistent.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-01 22:43:11 +00:00
|
|
|
|
drm: revamp locking around fb creation/destruction
Well, at least step 1. The goal here is that framebuffer objects can
survive outside of the mode_config lock, with just a reference held
as protection. The first step to get there is to introduce a special
fb_lock which protects fb lookup, creation and destruction, to make
them appear atomic.
This new fb_lock can nest within the mode_config lock. But the idea is
(once the reference counting part is completed) that we only quickly
take that fb_lock to lookup a framebuffer and grab a reference,
without any other locks involved.
vmwgfx is the only driver which does framebuffer lookups itself, also
wrap those calls to drm_mode_object_find with the new lock.
Also protect the fb_list walking in i915 and omapdrm with the new lock.
As a slight complication there's also the list of user-created fbs
attached to the file private. The problem now is that at fclose() time
we need to walk that list, eventually do a modeset call to remove the
fb from active usage (and are required to be able to take the
mode_config lock), but in the end we need to grab the new fb_lock to
remove the fb from the list. The easiest solution is to add another
mutex to protect this per-file list.
Currently that new fbs_lock nests within the modeset locks and so
appears redudant. But later patches will switch around this sequence
so that taking the modeset locks in the fb destruction path is
optional in the fastpath. Ultimately the goal is that addfb and rmfb
do not require the mode_config lock, since otherwise they have the
potential to introduce stalls in the pageflip sequence of a compositor
(if the compositor e.g. switches to a fullscreen client or if it
enables a plane). But that requires a few more steps and hoops to jump
through.
Note that framebuffer creation/destruction is now double-protected -
once by the fb_lock and in parts by the idr_lock. The later would be
unnecessariy if framebuffers would have their own idr allocator. But
that's material for another patch (series).
v2: Properly initialize the fb->filp_head list in _init, otherwise the
newly added WARN to check whether the fb isn't on a fpriv list any
more will fail for driver-private objects.
v3: Fixup two error-case unlock bugs spotted by Richard Wilbur.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-10 20:19:18 +00:00
|
|
|
mutex_lock(&dev->mode_config.fb_lock);
|
2012-09-05 21:48:38 +00:00
|
|
|
list_del(&fb->head);
|
|
|
|
|
dev->mode_config.num_fb--;
|
drm: revamp locking around fb creation/destruction
Well, at least step 1. The goal here is that framebuffer objects can
survive outside of the mode_config lock, with just a reference held
as protection. The first step to get there is to introduce a special
fb_lock which protects fb lookup, creation and destruction, to make
them appear atomic.
This new fb_lock can nest within the mode_config lock. But the idea is
(once the reference counting part is completed) that we only quickly
take that fb_lock to lookup a framebuffer and grab a reference,
without any other locks involved.
vmwgfx is the only driver which does framebuffer lookups itself, also
wrap those calls to drm_mode_object_find with the new lock.
Also protect the fb_list walking in i915 and omapdrm with the new lock.
As a slight complication there's also the list of user-created fbs
attached to the file private. The problem now is that at fclose() time
we need to walk that list, eventually do a modeset call to remove the
fb from active usage (and are required to be able to take the
mode_config lock), but in the end we need to grab the new fb_lock to
remove the fb from the list. The easiest solution is to add another
mutex to protect this per-file list.
Currently that new fbs_lock nests within the modeset locks and so
appears redudant. But later patches will switch around this sequence
so that taking the modeset locks in the fb destruction path is
optional in the fastpath. Ultimately the goal is that addfb and rmfb
do not require the mode_config lock, since otherwise they have the
potential to introduce stalls in the pageflip sequence of a compositor
(if the compositor e.g. switches to a fullscreen client or if it
enables a plane). But that requires a few more steps and hoops to jump
through.
Note that framebuffer creation/destruction is now double-protected -
once by the fb_lock and in parts by the idr_lock. The later would be
unnecessariy if framebuffers would have their own idr allocator. But
that's material for another patch (series).
v2: Properly initialize the fb->filp_head list in _init, otherwise the
newly added WARN to check whether the fb isn't on a fpriv list any
more will fail for driver-private objects.
v3: Fixup two error-case unlock bugs spotted by Richard Wilbur.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-10 20:19:18 +00:00
|
|
|
mutex_unlock(&dev->mode_config.fb_lock);
|
2012-09-05 21:48:38 +00:00
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(drm_framebuffer_cleanup);
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* drm_framebuffer_remove - remove and unreference a framebuffer object
|
|
|
|
|
* @fb: framebuffer to remove
|
|
|
|
|
*
|
|
|
|
|
* Scans all the CRTCs and planes in @dev's mode_config. If they're
|
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-10 19:42:17 +00:00
|
|
|
* using @fb, removes it, setting it to NULL. Then drops the reference to the
|
2012-12-11 15:51:35 +00:00
|
|
|
* passed-in framebuffer. Might take the modeset locks.
|
|
|
|
|
*
|
|
|
|
|
* Note that this function optimizes the cleanup away if the caller holds the
|
|
|
|
|
* last reference to the framebuffer. It is also guaranteed to not take the
|
|
|
|
|
* modeset locks in this case.
|
2012-09-05 21:48:38 +00:00
|
|
|
*/
|
|
|
|
|
void drm_framebuffer_remove(struct drm_framebuffer *fb)
|
2008-11-07 22:05:41 +00:00
|
|
|
{
|
|
|
|
|
struct drm_device *dev = fb->dev;
|
|
|
|
|
struct drm_crtc *crtc;
|
2011-11-14 22:51:27 +00:00
|
|
|
struct drm_plane *plane;
|
2009-08-17 03:11:23 +00:00
|
|
|
struct drm_mode_set set;
|
|
|
|
|
int ret;
|
2008-11-07 22:05:41 +00:00
|
|
|
|
drm: revamp locking around fb creation/destruction
Well, at least step 1. The goal here is that framebuffer objects can
survive outside of the mode_config lock, with just a reference held
as protection. The first step to get there is to introduce a special
fb_lock which protects fb lookup, creation and destruction, to make
them appear atomic.
This new fb_lock can nest within the mode_config lock. But the idea is
(once the reference counting part is completed) that we only quickly
take that fb_lock to lookup a framebuffer and grab a reference,
without any other locks involved.
vmwgfx is the only driver which does framebuffer lookups itself, also
wrap those calls to drm_mode_object_find with the new lock.
Also protect the fb_list walking in i915 and omapdrm with the new lock.
As a slight complication there's also the list of user-created fbs
attached to the file private. The problem now is that at fclose() time
we need to walk that list, eventually do a modeset call to remove the
fb from active usage (and are required to be able to take the
mode_config lock), but in the end we need to grab the new fb_lock to
remove the fb from the list. The easiest solution is to add another
mutex to protect this per-file list.
Currently that new fbs_lock nests within the modeset locks and so
appears redudant. But later patches will switch around this sequence
so that taking the modeset locks in the fb destruction path is
optional in the fastpath. Ultimately the goal is that addfb and rmfb
do not require the mode_config lock, since otherwise they have the
potential to introduce stalls in the pageflip sequence of a compositor
(if the compositor e.g. switches to a fullscreen client or if it
enables a plane). But that requires a few more steps and hoops to jump
through.
Note that framebuffer creation/destruction is now double-protected -
once by the fb_lock and in parts by the idr_lock. The later would be
unnecessariy if framebuffers would have their own idr allocator. But
that's material for another patch (series).
v2: Properly initialize the fb->filp_head list in _init, otherwise the
newly added WARN to check whether the fb isn't on a fpriv list any
more will fail for driver-private objects.
v3: Fixup two error-case unlock bugs spotted by Richard Wilbur.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-10 20:19:18 +00:00
|
|
|
WARN_ON(!list_empty(&fb->filp_head));
|
drm: review locking rules in drm_crtc.c
- config_cleanup was confused: It claimed that callers need to hold
the modeset lock, but the connector|encoder_cleanup helpers grabbed
that themselves (note that crtc_cleanup did _not_ grab the modeset
lock). Which resulted in all drivers _not_ hodling the lock. Since
this is for single-threaded cleanup code, drop the requirement from
docs and also drop the lock_grabbing from all _cleanup functions.
- Kill the LOCKING section in the doctype, since clearly we're not
good enough to keep them up-to-date. And misleading locking
documentation is worse than useless (see e.g. the comment in the
vmgfx driver about the cleanup mess). And since for most functions
the very first line either grabs the lock or has a WARN_ON(!locked)
the documentation doesn't really add anything.
- Instead put in some effort into explaining the only two special
cases a bit better: config_init and config_cleanup are both called
from single-threaded setup/teardown code, so don't do any locking.
It's the driver's job though to enforce this.
- Where lacking, add a WARN_ON(!is_locked). Not many places though,
since locking around fbdev setup/teardown is through-roughly screwed
up, and so will break almost every single WARN annotation I've tried
to add.
- Add a drm_modeset_is_locked helper - the Grate Modset Locking Rework
will use the compiler to assist in the big reorg by renaming the
mode lock, so start encapsulating things. Unfortunately this ended
up in the "wrong" header file since it needs the definition of
struct drm_device.
v2: Drop most WARNS again - we hit them all over the place, mostly in
the setup and teardown sequences. And trying to fix it up leads to
nice deadlocks, since the locking in the setup code is really
inconsistent.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-01 22:43:11 +00:00
|
|
|
|
2012-12-11 15:51:35 +00:00
|
|
|
/*
|
|
|
|
|
* drm ABI mandates that we remove any deleted framebuffers from active
|
|
|
|
|
* useage. But since most sane clients only remove framebuffers they no
|
|
|
|
|
* longer need, try to optimize this away.
|
|
|
|
|
*
|
|
|
|
|
* Since we're holding a reference ourselves, observing a refcount of 1
|
|
|
|
|
* means that we're the last holder and can skip it. Also, the refcount
|
|
|
|
|
* can never increase from 1 again, so we don't need any barriers or
|
|
|
|
|
* locks.
|
|
|
|
|
*
|
|
|
|
|
* Note that userspace could try to race with use and instate a new
|
|
|
|
|
* usage _after_ we've cleared all current ones. End result will be an
|
|
|
|
|
* in-use fb with fb-id == 0. Userspace is allowed to shoot its own foot
|
|
|
|
|
* in this manner.
|
|
|
|
|
*/
|
|
|
|
|
if (atomic_read(&fb->refcount.refcount) > 1) {
|
|
|
|
|
drm_modeset_lock_all(dev);
|
|
|
|
|
/* remove from any CRTC */
|
|
|
|
|
list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
|
2014-04-01 22:22:40 +00:00
|
|
|
if (crtc->primary->fb == fb) {
|
2012-12-11 15:51:35 +00:00
|
|
|
/* should turn off the crtc */
|
|
|
|
|
memset(&set, 0, sizeof(struct drm_mode_set));
|
|
|
|
|
set.crtc = crtc;
|
|
|
|
|
set.fb = NULL;
|
|
|
|
|
ret = drm_mode_set_config_internal(&set);
|
|
|
|
|
if (ret)
|
|
|
|
|
DRM_ERROR("failed to reset crtc %p when fb was deleted\n", crtc);
|
|
|
|
|
}
|
2009-08-17 03:11:23 +00:00
|
|
|
}
|
2008-11-07 22:05:41 +00:00
|
|
|
|
2012-12-11 15:51:35 +00:00
|
|
|
list_for_each_entry(plane, &dev->mode_config.plane_list, head) {
|
2013-06-03 13:10:40 +00:00
|
|
|
if (plane->fb == fb)
|
|
|
|
|
drm_plane_force_disable(plane);
|
2011-11-14 22:51:27 +00:00
|
|
|
}
|
2012-12-11 15:51:35 +00:00
|
|
|
drm_modeset_unlock_all(dev);
|
2011-11-14 22:51:27 +00:00
|
|
|
}
|
|
|
|
|
|
2012-09-05 21:48:38 +00:00
|
|
|
drm_framebuffer_unreference(fb);
|
2008-11-07 22:05:41 +00:00
|
|
|
}
|
2012-09-05 21:48:38 +00:00
|
|
|
EXPORT_SYMBOL(drm_framebuffer_remove);
|
2008-11-07 22:05:41 +00:00
|
|
|
|
2013-11-19 17:10:12 +00:00
|
|
|
DEFINE_WW_CLASS(crtc_ww_class);
|
|
|
|
|
|
2008-11-07 22:05:41 +00:00
|
|
|
/**
|
2014-04-01 22:22:38 +00:00
|
|
|
* drm_crtc_init_with_planes - Initialise a new CRTC object with
|
|
|
|
|
* specified primary and cursor planes.
|
2008-11-07 22:05:41 +00:00
|
|
|
* @dev: DRM device
|
|
|
|
|
* @crtc: CRTC object to init
|
2014-04-01 22:22:38 +00:00
|
|
|
* @primary: Primary plane for CRTC
|
|
|
|
|
* @cursor: Cursor plane for CRTC
|
2008-11-07 22:05:41 +00:00
|
|
|
* @funcs: callbacks for the new CRTC
|
|
|
|
|
*
|
2013-06-05 12:39:55 +00:00
|
|
|
* Inits a new object created as base part of a driver crtc object.
|
2012-03-13 10:35:48 +00:00
|
|
|
*
|
2014-03-10 20:33:02 +00:00
|
|
|
* Returns:
|
2012-03-13 10:35:48 +00:00
|
|
|
* Zero on success, error code on failure.
|
2008-11-07 22:05:41 +00:00
|
|
|
*/
|
2014-04-01 22:22:38 +00:00
|
|
|
int drm_crtc_init_with_planes(struct drm_device *dev, struct drm_crtc *crtc,
|
|
|
|
|
struct drm_plane *primary,
|
|
|
|
|
void *cursor,
|
|
|
|
|
const struct drm_crtc_funcs *funcs)
|
2008-11-07 22:05:41 +00:00
|
|
|
{
|
2013-11-19 17:10:12 +00:00
|
|
|
struct drm_mode_config *config = &dev->mode_config;
|
2012-03-13 10:35:48 +00:00
|
|
|
int ret;
|
|
|
|
|
|
2008-11-07 22:05:41 +00:00
|
|
|
crtc->dev = dev;
|
|
|
|
|
crtc->funcs = funcs;
|
2012-09-04 16:35:56 +00:00
|
|
|
crtc->invert_dimensions = false;
|
2008-11-07 22:05:41 +00:00
|
|
|
|
2012-12-01 23:28:11 +00:00
|
|
|
drm_modeset_lock_all(dev);
|
2013-11-19 17:10:12 +00:00
|
|
|
drm_modeset_lock_init(&crtc->mutex);
|
|
|
|
|
/* dropped by _unlock_all(): */
|
|
|
|
|
drm_modeset_lock(&crtc->mutex, config->acquire_ctx);
|
2012-03-13 10:35:48 +00:00
|
|
|
|
|
|
|
|
ret = drm_mode_object_get(dev, &crtc->base, DRM_MODE_OBJECT_CRTC);
|
|
|
|
|
if (ret)
|
|
|
|
|
goto out;
|
2008-11-07 22:05:41 +00:00
|
|
|
|
2012-05-15 21:09:05 +00:00
|
|
|
crtc->base.properties = &crtc->properties;
|
|
|
|
|
|
2013-11-19 17:10:12 +00:00
|
|
|
list_add_tail(&crtc->head, &config->crtc_list);
|
|
|
|
|
config->num_crtc++;
|
2012-03-13 10:35:48 +00:00
|
|
|
|
2014-04-01 22:22:38 +00:00
|
|
|
crtc->primary = primary;
|
|
|
|
|
if (primary)
|
|
|
|
|
primary->possible_crtcs = 1 << drm_crtc_index(crtc);
|
|
|
|
|
|
2012-03-13 10:35:48 +00:00
|
|
|
out:
|
2012-12-01 23:28:11 +00:00
|
|
|
drm_modeset_unlock_all(dev);
|
2012-03-13 10:35:48 +00:00
|
|
|
|
|
|
|
|
return ret;
|
2008-11-07 22:05:41 +00:00
|
|
|
}
|
2014-04-01 22:22:38 +00:00
|
|
|
EXPORT_SYMBOL(drm_crtc_init_with_planes);
|
2008-11-07 22:05:41 +00:00
|
|
|
|
|
|
|
|
/**
|
2013-06-05 12:39:55 +00:00
|
|
|
* drm_crtc_cleanup - Clean up the core crtc usage
|
2008-11-07 22:05:41 +00:00
|
|
|
* @crtc: CRTC to cleanup
|
|
|
|
|
*
|
2013-06-05 12:39:55 +00:00
|
|
|
* This function cleans up @crtc and removes it from the DRM mode setting
|
|
|
|
|
* core. Note that the function does *not* free the crtc structure itself,
|
|
|
|
|
* this is the responsibility of the caller.
|
2008-11-07 22:05:41 +00:00
|
|
|
*/
|
|
|
|
|
void drm_crtc_cleanup(struct drm_crtc *crtc)
|
|
|
|
|
{
|
|
|
|
|
struct drm_device *dev = crtc->dev;
|
|
|
|
|
|
2012-11-19 09:44:56 +00:00
|
|
|
kfree(crtc->gamma_store);
|
|
|
|
|
crtc->gamma_store = NULL;
|
2008-11-07 22:05:41 +00:00
|
|
|
|
2013-11-19 17:10:12 +00:00
|
|
|
drm_modeset_lock_fini(&crtc->mutex);
|
|
|
|
|
|
2008-11-07 22:05:41 +00:00
|
|
|
drm_mode_object_put(dev, &crtc->base);
|
|
|
|
|
list_del(&crtc->head);
|
|
|
|
|
dev->mode_config.num_crtc--;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(drm_crtc_cleanup);
|
|
|
|
|
|
2014-01-02 21:27:33 +00:00
|
|
|
/**
|
|
|
|
|
* drm_crtc_index - find the index of a registered CRTC
|
|
|
|
|
* @crtc: CRTC to find index for
|
|
|
|
|
*
|
|
|
|
|
* Given a registered CRTC, return the index of that CRTC within a DRM
|
|
|
|
|
* device's list of CRTCs.
|
|
|
|
|
*/
|
|
|
|
|
unsigned int drm_crtc_index(struct drm_crtc *crtc)
|
|
|
|
|
{
|
|
|
|
|
unsigned int index = 0;
|
|
|
|
|
struct drm_crtc *tmp;
|
|
|
|
|
|
|
|
|
|
list_for_each_entry(tmp, &crtc->dev->mode_config.crtc_list, head) {
|
|
|
|
|
if (tmp == crtc)
|
|
|
|
|
return index;
|
|
|
|
|
|
|
|
|
|
index++;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
BUG();
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(drm_crtc_index);
|
|
|
|
|
|
2013-08-19 23:53:06 +00:00
|
|
|
/*
|
2008-11-07 22:05:41 +00:00
|
|
|
* drm_mode_remove - remove and free a mode
|
|
|
|
|
* @connector: connector list to modify
|
|
|
|
|
* @mode: mode to remove
|
|
|
|
|
*
|
|
|
|
|
* Remove @mode from @connector's mode list, then free it.
|
|
|
|
|
*/
|
2013-08-19 23:53:06 +00:00
|
|
|
static void drm_mode_remove(struct drm_connector *connector,
|
|
|
|
|
struct drm_display_mode *mode)
|
2008-11-07 22:05:41 +00:00
|
|
|
{
|
|
|
|
|
list_del(&mode->head);
|
2012-02-01 10:38:19 +00:00
|
|
|
drm_mode_destroy(connector->dev, mode);
|
2008-11-07 22:05:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* drm_connector_init - Init a preallocated connector
|
|
|
|
|
* @dev: DRM device
|
|
|
|
|
* @connector: the connector to init
|
|
|
|
|
* @funcs: callbacks for this connector
|
2012-12-01 23:09:18 +00:00
|
|
|
* @connector_type: user visible type of the connector
|
2008-11-07 22:05:41 +00:00
|
|
|
*
|
|
|
|
|
* Initialises a preallocated connector. Connectors should be
|
|
|
|
|
* subclassed as part of driver connector objects.
|
2012-03-13 10:35:48 +00:00
|
|
|
*
|
2014-03-10 20:33:02 +00:00
|
|
|
* Returns:
|
2012-03-13 10:35:48 +00:00
|
|
|
* Zero on success, error code on failure.
|
2008-11-07 22:05:41 +00:00
|
|
|
*/
|
2012-03-13 10:35:48 +00:00
|
|
|
int drm_connector_init(struct drm_device *dev,
|
|
|
|
|
struct drm_connector *connector,
|
|
|
|
|
const struct drm_connector_funcs *funcs,
|
|
|
|
|
int connector_type)
|
2008-11-07 22:05:41 +00:00
|
|
|
{
|
2012-03-13 10:35:48 +00:00
|
|
|
int ret;
|
2013-08-08 02:34:48 +00:00
|
|
|
struct ida *connector_ida =
|
|
|
|
|
&drm_connector_enum_list[connector_type].ida;
|
2012-03-13 10:35:48 +00:00
|
|
|
|
2012-12-01 23:28:11 +00:00
|
|
|
drm_modeset_lock_all(dev);
|
2008-11-07 22:05:41 +00:00
|
|
|
|
2012-03-13 10:35:48 +00:00
|
|
|
ret = drm_mode_object_get(dev, &connector->base, DRM_MODE_OBJECT_CONNECTOR);
|
|
|
|
|
if (ret)
|
2014-05-14 13:58:19 +00:00
|
|
|
goto out_unlock;
|
2012-03-13 10:35:48 +00:00
|
|
|
|
2012-05-15 21:09:01 +00:00
|
|
|
connector->base.properties = &connector->properties;
|
2008-11-07 22:05:41 +00:00
|
|
|
connector->dev = dev;
|
|
|
|
|
connector->funcs = funcs;
|
|
|
|
|
connector->connector_type = connector_type;
|
|
|
|
|
connector->connector_type_id =
|
2013-08-08 02:34:48 +00:00
|
|
|
ida_simple_get(connector_ida, 1, 0, GFP_KERNEL);
|
|
|
|
|
if (connector->connector_type_id < 0) {
|
|
|
|
|
ret = connector->connector_type_id;
|
2014-05-14 13:58:19 +00:00
|
|
|
goto out_put;
|
2013-08-08 02:34:48 +00:00
|
|
|
}
|
2014-05-14 13:58:19 +00:00
|
|
|
connector->name =
|
|
|
|
|
kasprintf(GFP_KERNEL, "%s-%d",
|
|
|
|
|
drm_connector_enum_list[connector_type].name,
|
|
|
|
|
connector->connector_type_id);
|
|
|
|
|
if (!connector->name) {
|
|
|
|
|
ret = -ENOMEM;
|
|
|
|
|
goto out_put;
|
|
|
|
|
}
|
|
|
|
|
|
2008-11-07 22:05:41 +00:00
|
|
|
INIT_LIST_HEAD(&connector->probed_modes);
|
|
|
|
|
INIT_LIST_HEAD(&connector->modes);
|
|
|
|
|
connector->edid_blob_ptr = NULL;
|
2012-10-23 18:23:35 +00:00
|
|
|
connector->status = connector_status_unknown;
|
2008-11-07 22:05:41 +00:00
|
|
|
|
|
|
|
|
list_add_tail(&connector->head, &dev->mode_config.connector_list);
|
|
|
|
|
dev->mode_config.num_connector++;
|
|
|
|
|
|
2011-10-22 08:36:19 +00:00
|
|
|
if (connector_type != DRM_MODE_CONNECTOR_VIRTUAL)
|
2012-10-12 01:50:56 +00:00
|
|
|
drm_object_attach_property(&connector->base,
|
2011-10-22 08:36:19 +00:00
|
|
|
dev->mode_config.edid_property,
|
|
|
|
|
0);
|
2008-11-07 22:05:41 +00:00
|
|
|
|
2012-10-12 01:50:56 +00:00
|
|
|
drm_object_attach_property(&connector->base,
|
2008-11-07 22:05:41 +00:00
|
|
|
dev->mode_config.dpms_property, 0);
|
|
|
|
|
|
2014-05-14 13:58:19 +00:00
|
|
|
out_put:
|
|
|
|
|
if (ret)
|
|
|
|
|
drm_mode_object_put(dev, &connector->base);
|
|
|
|
|
|
|
|
|
|
out_unlock:
|
2012-12-01 23:28:11 +00:00
|
|
|
drm_modeset_unlock_all(dev);
|
2012-03-13 10:35:48 +00:00
|
|
|
|
|
|
|
|
return ret;
|
2008-11-07 22:05:41 +00:00
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(drm_connector_init);
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* drm_connector_cleanup - cleans up an initialised connector
|
|
|
|
|
* @connector: connector to cleanup
|
|
|
|
|
*
|
|
|
|
|
* Cleans up the connector but doesn't free the object.
|
|
|
|
|
*/
|
|
|
|
|
void drm_connector_cleanup(struct drm_connector *connector)
|
|
|
|
|
{
|
|
|
|
|
struct drm_device *dev = connector->dev;
|
|
|
|
|
struct drm_display_mode *mode, *t;
|
|
|
|
|
|
|
|
|
|
list_for_each_entry_safe(mode, t, &connector->probed_modes, head)
|
|
|
|
|
drm_mode_remove(connector, mode);
|
|
|
|
|
|
|
|
|
|
list_for_each_entry_safe(mode, t, &connector->modes, head)
|
|
|
|
|
drm_mode_remove(connector, mode);
|
|
|
|
|
|
2013-08-08 02:34:48 +00:00
|
|
|
ida_remove(&drm_connector_enum_list[connector->connector_type].ida,
|
|
|
|
|
connector->connector_type_id);
|
|
|
|
|
|
2008-11-07 22:05:41 +00:00
|
|
|
drm_mode_object_put(dev, &connector->base);
|
2014-05-14 13:58:19 +00:00
|
|
|
kfree(connector->name);
|
|
|
|
|
connector->name = NULL;
|
2008-11-07 22:05:41 +00:00
|
|
|
list_del(&connector->head);
|
2011-08-27 02:06:21 +00:00
|
|
|
dev->mode_config.num_connector--;
|
2008-11-07 22:05:41 +00:00
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(drm_connector_cleanup);
|
|
|
|
|
|
2014-03-10 20:33:02 +00:00
|
|
|
/**
|
|
|
|
|
* drm_connector_unplug_all - unregister connector userspace interfaces
|
|
|
|
|
* @dev: drm device
|
|
|
|
|
*
|
|
|
|
|
* This function unregisters all connector userspace interfaces in sysfs. Should
|
|
|
|
|
* be call when the device is disconnected, e.g. from an usb driver's
|
|
|
|
|
* ->disconnect callback.
|
|
|
|
|
*/
|
2012-02-20 14:16:40 +00:00
|
|
|
void drm_connector_unplug_all(struct drm_device *dev)
|
|
|
|
|
{
|
|
|
|
|
struct drm_connector *connector;
|
|
|
|
|
|
|
|
|
|
/* taking the mode config mutex ends up in a clash with sysfs */
|
|
|
|
|
list_for_each_entry(connector, &dev->mode_config.connector_list, head)
|
|
|
|
|
drm_sysfs_connector_remove(connector);
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(drm_connector_unplug_all);
|
|
|
|
|
|
2014-03-10 20:33:02 +00:00
|
|
|
/**
|
|
|
|
|
* drm_bridge_init - initialize a drm transcoder/bridge
|
|
|
|
|
* @dev: drm device
|
|
|
|
|
* @bridge: transcoder/bridge to set up
|
|
|
|
|
* @funcs: bridge function table
|
|
|
|
|
*
|
|
|
|
|
* Initialises a preallocated bridge. Bridges should be
|
|
|
|
|
* subclassed as part of driver connector objects.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* Zero on success, error code on failure.
|
|
|
|
|
*/
|
2013-08-14 20:47:37 +00:00
|
|
|
int drm_bridge_init(struct drm_device *dev, struct drm_bridge *bridge,
|
|
|
|
|
const struct drm_bridge_funcs *funcs)
|
|
|
|
|
{
|
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
|
|
drm_modeset_lock_all(dev);
|
|
|
|
|
|
|
|
|
|
ret = drm_mode_object_get(dev, &bridge->base, DRM_MODE_OBJECT_BRIDGE);
|
|
|
|
|
if (ret)
|
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
|
|
bridge->dev = dev;
|
|
|
|
|
bridge->funcs = funcs;
|
|
|
|
|
|
|
|
|
|
list_add_tail(&bridge->head, &dev->mode_config.bridge_list);
|
|
|
|
|
dev->mode_config.num_bridge++;
|
|
|
|
|
|
|
|
|
|
out:
|
|
|
|
|
drm_modeset_unlock_all(dev);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(drm_bridge_init);
|
|
|
|
|
|
2014-03-10 20:33:02 +00:00
|
|
|
/**
|
|
|
|
|
* drm_bridge_cleanup - cleans up an initialised bridge
|
|
|
|
|
* @bridge: bridge to cleanup
|
|
|
|
|
*
|
|
|
|
|
* Cleans up the bridge but doesn't free the object.
|
|
|
|
|
*/
|
2013-08-14 20:47:37 +00:00
|
|
|
void drm_bridge_cleanup(struct drm_bridge *bridge)
|
|
|
|
|
{
|
|
|
|
|
struct drm_device *dev = bridge->dev;
|
|
|
|
|
|
|
|
|
|
drm_modeset_lock_all(dev);
|
|
|
|
|
drm_mode_object_put(dev, &bridge->base);
|
|
|
|
|
list_del(&bridge->head);
|
|
|
|
|
dev->mode_config.num_bridge--;
|
|
|
|
|
drm_modeset_unlock_all(dev);
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(drm_bridge_cleanup);
|
|
|
|
|
|
2014-03-10 20:33:02 +00:00
|
|
|
/**
|
|
|
|
|
* drm_encoder_init - Init a preallocated encoder
|
|
|
|
|
* @dev: drm device
|
|
|
|
|
* @encoder: the encoder to init
|
|
|
|
|
* @funcs: callbacks for this encoder
|
|
|
|
|
* @encoder_type: user visible type of the encoder
|
|
|
|
|
*
|
|
|
|
|
* Initialises a preallocated encoder. Encoder should be
|
|
|
|
|
* subclassed as part of driver encoder objects.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* Zero on success, error code on failure.
|
|
|
|
|
*/
|
2012-03-13 10:35:48 +00:00
|
|
|
int drm_encoder_init(struct drm_device *dev,
|
2012-02-20 14:16:40 +00:00
|
|
|
struct drm_encoder *encoder,
|
|
|
|
|
const struct drm_encoder_funcs *funcs,
|
|
|
|
|
int encoder_type)
|
2008-11-07 22:05:41 +00:00
|
|
|
{
|
2012-03-13 10:35:48 +00:00
|
|
|
int ret;
|
|
|
|
|
|
2012-12-01 23:28:11 +00:00
|
|
|
drm_modeset_lock_all(dev);
|
2008-11-07 22:05:41 +00:00
|
|
|
|
2012-03-13 10:35:48 +00:00
|
|
|
ret = drm_mode_object_get(dev, &encoder->base, DRM_MODE_OBJECT_ENCODER);
|
|
|
|
|
if (ret)
|
2014-05-14 13:58:20 +00:00
|
|
|
goto out_unlock;
|
2008-11-07 22:05:41 +00:00
|
|
|
|
2012-03-13 10:35:48 +00:00
|
|
|
encoder->dev = dev;
|
2008-11-07 22:05:41 +00:00
|
|
|
encoder->encoder_type = encoder_type;
|
|
|
|
|
encoder->funcs = funcs;
|
2014-05-14 13:58:20 +00:00
|
|
|
encoder->name = kasprintf(GFP_KERNEL, "%s-%d",
|
|
|
|
|
drm_encoder_enum_list[encoder_type].name,
|
|
|
|
|
encoder->base.id);
|
|
|
|
|
if (!encoder->name) {
|
|
|
|
|
ret = -ENOMEM;
|
|
|
|
|
goto out_put;
|
|
|
|
|
}
|
2008-11-07 22:05:41 +00:00
|
|
|
|
|
|
|
|
list_add_tail(&encoder->head, &dev->mode_config.encoder_list);
|
|
|
|
|
dev->mode_config.num_encoder++;
|
|
|
|
|
|
2014-05-14 13:58:20 +00:00
|
|
|
out_put:
|
|
|
|
|
if (ret)
|
|
|
|
|
drm_mode_object_put(dev, &encoder->base);
|
|
|
|
|
|
|
|
|
|
out_unlock:
|
2012-12-01 23:28:11 +00:00
|
|
|
drm_modeset_unlock_all(dev);
|
2012-03-13 10:35:48 +00:00
|
|
|
|
|
|
|
|
return ret;
|
2008-11-07 22:05:41 +00:00
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(drm_encoder_init);
|
|
|
|
|
|
2014-03-10 20:33:02 +00:00
|
|
|
/**
|
|
|
|
|
* drm_encoder_cleanup - cleans up an initialised encoder
|
|
|
|
|
* @encoder: encoder to cleanup
|
|
|
|
|
*
|
|
|
|
|
* Cleans up the encoder but doesn't free the object.
|
|
|
|
|
*/
|
2008-11-07 22:05:41 +00:00
|
|
|
void drm_encoder_cleanup(struct drm_encoder *encoder)
|
|
|
|
|
{
|
|
|
|
|
struct drm_device *dev = encoder->dev;
|
2012-12-01 23:28:11 +00:00
|
|
|
drm_modeset_lock_all(dev);
|
2008-11-07 22:05:41 +00:00
|
|
|
drm_mode_object_put(dev, &encoder->base);
|
2014-05-14 13:58:20 +00:00
|
|
|
kfree(encoder->name);
|
|
|
|
|
encoder->name = NULL;
|
2008-11-07 22:05:41 +00:00
|
|
|
list_del(&encoder->head);
|
2011-08-27 02:06:21 +00:00
|
|
|
dev->mode_config.num_encoder--;
|
2012-12-01 23:28:11 +00:00
|
|
|
drm_modeset_unlock_all(dev);
|
2008-11-07 22:05:41 +00:00
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(drm_encoder_cleanup);
|
|
|
|
|
|
2013-06-05 12:39:56 +00:00
|
|
|
/**
|
2014-04-01 22:22:36 +00:00
|
|
|
* drm_universal_plane_init - Initialize a new universal plane object
|
2013-06-05 12:39:56 +00:00
|
|
|
* @dev: DRM device
|
|
|
|
|
* @plane: plane object to init
|
|
|
|
|
* @possible_crtcs: bitmask of possible CRTCs
|
|
|
|
|
* @funcs: callbacks for the new plane
|
|
|
|
|
* @formats: array of supported formats (%DRM_FORMAT_*)
|
|
|
|
|
* @format_count: number of elements in @formats
|
2014-04-01 22:22:36 +00:00
|
|
|
* @type: type of plane (overlay, primary, cursor)
|
2013-06-05 12:39:56 +00:00
|
|
|
*
|
2014-04-01 22:22:36 +00:00
|
|
|
* Initializes a plane object of type @type.
|
2013-06-05 12:39:56 +00:00
|
|
|
*
|
2014-03-10 20:33:02 +00:00
|
|
|
* Returns:
|
2013-06-05 12:39:56 +00:00
|
|
|
* Zero on success, error code on failure.
|
|
|
|
|
*/
|
2014-04-01 22:22:36 +00:00
|
|
|
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-14 22:51:27 +00:00
|
|
|
{
|
2012-03-13 10:35:48 +00:00
|
|
|
int ret;
|
|
|
|
|
|
2012-12-01 23:28:11 +00:00
|
|
|
drm_modeset_lock_all(dev);
|
2011-11-14 22:51:27 +00:00
|
|
|
|
2012-03-13 10:35:48 +00:00
|
|
|
ret = drm_mode_object_get(dev, &plane->base, DRM_MODE_OBJECT_PLANE);
|
|
|
|
|
if (ret)
|
|
|
|
|
goto out;
|
|
|
|
|
|
2012-05-17 08:23:27 +00:00
|
|
|
plane->base.properties = &plane->properties;
|
2011-11-14 22:51:27 +00:00
|
|
|
plane->dev = dev;
|
|
|
|
|
plane->funcs = funcs;
|
|
|
|
|
plane->format_types = kmalloc(sizeof(uint32_t) * format_count,
|
|
|
|
|
GFP_KERNEL);
|
|
|
|
|
if (!plane->format_types) {
|
|
|
|
|
DRM_DEBUG_KMS("out of memory when allocating plane\n");
|
|
|
|
|
drm_mode_object_put(dev, &plane->base);
|
2012-03-13 10:35:48 +00:00
|
|
|
ret = -ENOMEM;
|
|
|
|
|
goto out;
|
2011-11-14 22:51:27 +00:00
|
|
|
}
|
|
|
|
|
|
2011-11-14 22:51:28 +00:00
|
|
|
memcpy(plane->format_types, formats, format_count * sizeof(uint32_t));
|
2011-11-14 22:51:27 +00:00
|
|
|
plane->format_count = format_count;
|
|
|
|
|
plane->possible_crtcs = possible_crtcs;
|
2014-04-01 22:22:36 +00:00
|
|
|
plane->type = type;
|
2011-11-14 22:51:27 +00:00
|
|
|
|
2014-04-01 22:22:36 +00:00
|
|
|
list_add_tail(&plane->head, &dev->mode_config.plane_list);
|
|
|
|
|
dev->mode_config.num_total_plane++;
|
|
|
|
|
if (plane->type == DRM_PLANE_TYPE_OVERLAY)
|
|
|
|
|
dev->mode_config.num_overlay_plane++;
|
2011-11-14 22:51:27 +00:00
|
|
|
|
2014-04-02 00:16:57 +00:00
|
|
|
drm_object_attach_property(&plane->base,
|
|
|
|
|
dev->mode_config.plane_type_property,
|
|
|
|
|
plane->type);
|
|
|
|
|
|
2012-03-13 10:35:48 +00:00
|
|
|
out:
|
2012-12-01 23:28:11 +00:00
|
|
|
drm_modeset_unlock_all(dev);
|
2011-11-14 22:51:27 +00:00
|
|
|
|
2012-03-13 10:35:48 +00:00
|
|
|
return ret;
|
2011-11-14 22:51:27 +00:00
|
|
|
}
|
2014-04-01 22:22:36 +00:00
|
|
|
EXPORT_SYMBOL(drm_universal_plane_init);
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* drm_plane_init - Initialize a legacy plane
|
|
|
|
|
* @dev: DRM device
|
|
|
|
|
* @plane: plane object to init
|
|
|
|
|
* @possible_crtcs: bitmask of possible CRTCs
|
|
|
|
|
* @funcs: callbacks for the new plane
|
|
|
|
|
* @formats: array of supported formats (%DRM_FORMAT_*)
|
|
|
|
|
* @format_count: number of elements in @formats
|
|
|
|
|
* @is_primary: plane type (primary vs overlay)
|
|
|
|
|
*
|
|
|
|
|
* Legacy API to initialize a DRM plane.
|
|
|
|
|
*
|
|
|
|
|
* New drivers should call drm_universal_plane_init() instead.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* Zero on success, error code on failure.
|
|
|
|
|
*/
|
|
|
|
|
int drm_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,
|
|
|
|
|
bool is_primary)
|
|
|
|
|
{
|
|
|
|
|
enum drm_plane_type type;
|
|
|
|
|
|
|
|
|
|
type = is_primary ? DRM_PLANE_TYPE_PRIMARY : DRM_PLANE_TYPE_OVERLAY;
|
|
|
|
|
return drm_universal_plane_init(dev, plane, possible_crtcs, funcs,
|
|
|
|
|
formats, format_count, type);
|
|
|
|
|
}
|
2011-11-14 22:51:27 +00:00
|
|
|
EXPORT_SYMBOL(drm_plane_init);
|
|
|
|
|
|
2013-06-05 12:39:56 +00:00
|
|
|
/**
|
|
|
|
|
* drm_plane_cleanup - Clean up the core plane usage
|
|
|
|
|
* @plane: plane to cleanup
|
|
|
|
|
*
|
|
|
|
|
* This function cleans up @plane and removes it from the DRM mode setting
|
|
|
|
|
* core. Note that the function does *not* free the plane structure itself,
|
|
|
|
|
* this is the responsibility of the caller.
|
|
|
|
|
*/
|
2011-11-14 22:51:27 +00:00
|
|
|
void drm_plane_cleanup(struct drm_plane *plane)
|
|
|
|
|
{
|
|
|
|
|
struct drm_device *dev = plane->dev;
|
|
|
|
|
|
2012-12-01 23:28:11 +00:00
|
|
|
drm_modeset_lock_all(dev);
|
2011-11-14 22:51:27 +00:00
|
|
|
kfree(plane->format_types);
|
|
|
|
|
drm_mode_object_put(dev, &plane->base);
|
2014-04-01 22:22:36 +00:00
|
|
|
|
|
|
|
|
BUG_ON(list_empty(&plane->head));
|
|
|
|
|
|
|
|
|
|
list_del(&plane->head);
|
|
|
|
|
dev->mode_config.num_total_plane--;
|
|
|
|
|
if (plane->type == DRM_PLANE_TYPE_OVERLAY)
|
|
|
|
|
dev->mode_config.num_overlay_plane--;
|
2012-12-01 23:28:11 +00:00
|
|
|
drm_modeset_unlock_all(dev);
|
2011-11-14 22:51:27 +00:00
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(drm_plane_cleanup);
|
|
|
|
|
|
2013-06-05 12:39:56 +00:00
|
|
|
/**
|
|
|
|
|
* drm_plane_force_disable - Forcibly disable a plane
|
|
|
|
|
* @plane: plane to disable
|
|
|
|
|
*
|
|
|
|
|
* Forces the plane to be disabled.
|
|
|
|
|
*
|
|
|
|
|
* Used when the plane's current framebuffer is destroyed,
|
|
|
|
|
* and when restoring fbdev mode.
|
|
|
|
|
*/
|
2013-06-03 13:10:40 +00:00
|
|
|
void drm_plane_force_disable(struct drm_plane *plane)
|
|
|
|
|
{
|
2014-04-23 15:34:06 +00:00
|
|
|
struct drm_framebuffer *old_fb = plane->fb;
|
2013-06-03 13:10:40 +00:00
|
|
|
int ret;
|
|
|
|
|
|
2014-04-23 15:34:06 +00:00
|
|
|
if (!old_fb)
|
2013-06-03 13:10:40 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
ret = plane->funcs->disable_plane(plane);
|
2014-04-23 08:24:11 +00:00
|
|
|
if (ret) {
|
2013-06-03 13:10:40 +00:00
|
|
|
DRM_ERROR("failed to disable plane with busy fb\n");
|
2014-04-23 08:24:11 +00:00
|
|
|
return;
|
|
|
|
|
}
|
2013-06-03 13:10:40 +00:00
|
|
|
/* disconnect the plane from the fb and crtc: */
|
2014-04-23 15:34:06 +00:00
|
|
|
__drm_framebuffer_unreference(old_fb);
|
2013-06-03 13:10:40 +00:00
|
|
|
plane->fb = NULL;
|
|
|
|
|
plane->crtc = NULL;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(drm_plane_force_disable);
|
|
|
|
|
|
2008-11-07 22:05:41 +00:00
|
|
|
static int drm_mode_create_standard_connector_properties(struct drm_device *dev)
|
|
|
|
|
{
|
|
|
|
|
struct drm_property *edid;
|
|
|
|
|
struct drm_property *dpms;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Standard properties (apply to all connectors)
|
|
|
|
|
*/
|
|
|
|
|
edid = drm_property_create(dev, DRM_MODE_PROP_BLOB |
|
|
|
|
|
DRM_MODE_PROP_IMMUTABLE,
|
|
|
|
|
"EDID", 0);
|
|
|
|
|
dev->mode_config.edid_property = edid;
|
|
|
|
|
|
2012-02-06 09:58:17 +00:00
|
|
|
dpms = drm_property_create_enum(dev, 0,
|
|
|
|
|
"DPMS", drm_dpms_enum_list,
|
|
|
|
|
ARRAY_SIZE(drm_dpms_enum_list));
|
2008-11-07 22:05:41 +00:00
|
|
|
dev->mode_config.dpms_property = dpms;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2014-04-02 00:16:57 +00:00
|
|
|
static int drm_mode_create_standard_plane_properties(struct drm_device *dev)
|
|
|
|
|
{
|
|
|
|
|
struct drm_property *type;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Standard properties (apply to all planes)
|
|
|
|
|
*/
|
|
|
|
|
type = drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE,
|
|
|
|
|
"type", drm_plane_type_enum_list,
|
|
|
|
|
ARRAY_SIZE(drm_plane_type_enum_list));
|
|
|
|
|
dev->mode_config.plane_type_property = type;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2008-11-07 22:05:41 +00:00
|
|
|
/**
|
|
|
|
|
* drm_mode_create_dvi_i_properties - create DVI-I specific connector properties
|
|
|
|
|
* @dev: DRM device
|
|
|
|
|
*
|
|
|
|
|
* Called by a driver the first time a DVI-I connector is made.
|
|
|
|
|
*/
|
|
|
|
|
int drm_mode_create_dvi_i_properties(struct drm_device *dev)
|
|
|
|
|
{
|
|
|
|
|
struct drm_property *dvi_i_selector;
|
|
|
|
|
struct drm_property *dvi_i_subconnector;
|
|
|
|
|
|
|
|
|
|
if (dev->mode_config.dvi_i_select_subconnector_property)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
dvi_i_selector =
|
2012-02-06 09:58:17 +00:00
|
|
|
drm_property_create_enum(dev, 0,
|
2008-11-07 22:05:41 +00:00
|
|
|
"select subconnector",
|
2012-02-06 09:58:17 +00:00
|
|
|
drm_dvi_i_select_enum_list,
|
2008-11-07 22:05:41 +00:00
|
|
|
ARRAY_SIZE(drm_dvi_i_select_enum_list));
|
|
|
|
|
dev->mode_config.dvi_i_select_subconnector_property = dvi_i_selector;
|
|
|
|
|
|
2012-02-06 09:58:17 +00:00
|
|
|
dvi_i_subconnector = drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE,
|
2008-11-07 22:05:41 +00:00
|
|
|
"subconnector",
|
2012-02-06 09:58:17 +00:00
|
|
|
drm_dvi_i_subconnector_enum_list,
|
2008-11-07 22:05:41 +00:00
|
|
|
ARRAY_SIZE(drm_dvi_i_subconnector_enum_list));
|
|
|
|
|
dev->mode_config.dvi_i_subconnector_property = dvi_i_subconnector;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(drm_mode_create_dvi_i_properties);
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* drm_create_tv_properties - create TV specific connector properties
|
|
|
|
|
* @dev: DRM device
|
|
|
|
|
* @num_modes: number of different TV formats (modes) supported
|
|
|
|
|
* @modes: array of pointers to strings containing name of each format
|
|
|
|
|
*
|
|
|
|
|
* Called by a driver's TV initialization routine, this function creates
|
|
|
|
|
* the TV specific connector properties for a given device. Caller is
|
|
|
|
|
* responsible for allocating a list of format names and passing them to
|
|
|
|
|
* this routine.
|
|
|
|
|
*/
|
|
|
|
|
int drm_mode_create_tv_properties(struct drm_device *dev, int num_modes,
|
|
|
|
|
char *modes[])
|
|
|
|
|
{
|
|
|
|
|
struct drm_property *tv_selector;
|
|
|
|
|
struct drm_property *tv_subconnector;
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
if (dev->mode_config.tv_select_subconnector_property)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Basic connector properties
|
|
|
|
|
*/
|
2012-02-06 09:58:17 +00:00
|
|
|
tv_selector = drm_property_create_enum(dev, 0,
|
2008-11-07 22:05:41 +00:00
|
|
|
"select subconnector",
|
2012-02-06 09:58:17 +00:00
|
|
|
drm_tv_select_enum_list,
|
2008-11-07 22:05:41 +00:00
|
|
|
ARRAY_SIZE(drm_tv_select_enum_list));
|
|
|
|
|
dev->mode_config.tv_select_subconnector_property = tv_selector;
|
|
|
|
|
|
|
|
|
|
tv_subconnector =
|
2012-02-06 09:58:17 +00:00
|
|
|
drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE,
|
|
|
|
|
"subconnector",
|
|
|
|
|
drm_tv_subconnector_enum_list,
|
2008-11-07 22:05:41 +00:00
|
|
|
ARRAY_SIZE(drm_tv_subconnector_enum_list));
|
|
|
|
|
dev->mode_config.tv_subconnector_property = tv_subconnector;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Other, TV specific properties: margins & TV modes.
|
|
|
|
|
*/
|
|
|
|
|
dev->mode_config.tv_left_margin_property =
|
2012-02-06 09:58:18 +00:00
|
|
|
drm_property_create_range(dev, 0, "left margin", 0, 100);
|
2008-11-07 22:05:41 +00:00
|
|
|
|
|
|
|
|
dev->mode_config.tv_right_margin_property =
|
2012-02-06 09:58:18 +00:00
|
|
|
drm_property_create_range(dev, 0, "right margin", 0, 100);
|
2008-11-07 22:05:41 +00:00
|
|
|
|
|
|
|
|
dev->mode_config.tv_top_margin_property =
|
2012-02-06 09:58:18 +00:00
|
|
|
drm_property_create_range(dev, 0, "top margin", 0, 100);
|
2008-11-07 22:05:41 +00:00
|
|
|
|
|
|
|
|
dev->mode_config.tv_bottom_margin_property =
|
2012-02-06 09:58:18 +00:00
|
|
|
drm_property_create_range(dev, 0, "bottom margin", 0, 100);
|
2008-11-07 22:05:41 +00:00
|
|
|
|
|
|
|
|
dev->mode_config.tv_mode_property =
|
|
|
|
|
drm_property_create(dev, DRM_MODE_PROP_ENUM,
|
|
|
|
|
"mode", num_modes);
|
|
|
|
|
for (i = 0; i < num_modes; i++)
|
|
|
|
|
drm_property_add_enum(dev->mode_config.tv_mode_property, i,
|
|
|
|
|
i, modes[i]);
|
|
|
|
|
|
2009-08-02 02:19:20 +00:00
|
|
|
dev->mode_config.tv_brightness_property =
|
2012-02-06 09:58:18 +00:00
|
|
|
drm_property_create_range(dev, 0, "brightness", 0, 100);
|
2009-08-02 02:19:20 +00:00
|
|
|
|
|
|
|
|
dev->mode_config.tv_contrast_property =
|
2012-02-06 09:58:18 +00:00
|
|
|
drm_property_create_range(dev, 0, "contrast", 0, 100);
|
2009-08-02 02:19:20 +00:00
|
|
|
|
|
|
|
|
dev->mode_config.tv_flicker_reduction_property =
|
2012-02-06 09:58:18 +00:00
|
|
|
drm_property_create_range(dev, 0, "flicker reduction", 0, 100);
|
2009-08-02 02:19:20 +00:00
|
|
|
|
2009-08-12 00:30:10 +00:00
|
|
|
dev->mode_config.tv_overscan_property =
|
2012-02-06 09:58:18 +00:00
|
|
|
drm_property_create_range(dev, 0, "overscan", 0, 100);
|
2009-08-12 00:30:10 +00:00
|
|
|
|
|
|
|
|
dev->mode_config.tv_saturation_property =
|
2012-02-06 09:58:18 +00:00
|
|
|
drm_property_create_range(dev, 0, "saturation", 0, 100);
|
2009-08-12 00:30:10 +00:00
|
|
|
|
|
|
|
|
dev->mode_config.tv_hue_property =
|
2012-02-06 09:58:18 +00:00
|
|
|
drm_property_create_range(dev, 0, "hue", 0, 100);
|
2009-08-12 00:30:10 +00:00
|
|
|
|
2008-11-07 22:05:41 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(drm_mode_create_tv_properties);
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* drm_mode_create_scaling_mode_property - create scaling mode property
|
|
|
|
|
* @dev: DRM device
|
|
|
|
|
*
|
|
|
|
|
* Called by a driver the first time it's needed, must be attached to desired
|
|
|
|
|
* connectors.
|
|
|
|
|
*/
|
|
|
|
|
int drm_mode_create_scaling_mode_property(struct drm_device *dev)
|
|
|
|
|
{
|
|
|
|
|
struct drm_property *scaling_mode;
|
|
|
|
|
|
|
|
|
|
if (dev->mode_config.scaling_mode_property)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
scaling_mode =
|
2012-02-06 09:58:17 +00:00
|
|
|
drm_property_create_enum(dev, 0, "scaling mode",
|
|
|
|
|
drm_scaling_mode_enum_list,
|
2008-11-07 22:05:41 +00:00
|
|
|
ARRAY_SIZE(drm_scaling_mode_enum_list));
|
|
|
|
|
|
|
|
|
|
dev->mode_config.scaling_mode_property = scaling_mode;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(drm_mode_create_scaling_mode_property);
|
|
|
|
|
|
2009-12-03 23:25:47 +00:00
|
|
|
/**
|
|
|
|
|
* drm_mode_create_dirty_property - create dirty property
|
|
|
|
|
* @dev: DRM device
|
|
|
|
|
*
|
|
|
|
|
* Called by a driver the first time it's needed, must be attached to desired
|
|
|
|
|
* connectors.
|
|
|
|
|
*/
|
|
|
|
|
int drm_mode_create_dirty_info_property(struct drm_device *dev)
|
|
|
|
|
{
|
|
|
|
|
struct drm_property *dirty_info;
|
|
|
|
|
|
|
|
|
|
if (dev->mode_config.dirty_info_property)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
dirty_info =
|
2012-02-06 09:58:17 +00:00
|
|
|
drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE,
|
2009-12-03 23:25:47 +00:00
|
|
|
"dirty",
|
2012-02-06 09:58:17 +00:00
|
|
|
drm_dirty_info_enum_list,
|
2009-12-03 23:25:47 +00:00
|
|
|
ARRAY_SIZE(drm_dirty_info_enum_list));
|
|
|
|
|
dev->mode_config.dirty_info_property = dirty_info;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(drm_mode_create_dirty_info_property);
|
|
|
|
|
|
2013-04-25 17:09:20 +00:00
|
|
|
static int drm_mode_group_init(struct drm_device *dev, struct drm_mode_group *group)
|
2008-11-07 22:05:41 +00:00
|
|
|
{
|
|
|
|
|
uint32_t total_objects = 0;
|
|
|
|
|
|
|
|
|
|
total_objects += dev->mode_config.num_crtc;
|
|
|
|
|
total_objects += dev->mode_config.num_connector;
|
|
|
|
|
total_objects += dev->mode_config.num_encoder;
|
2013-08-14 20:47:37 +00:00
|
|
|
total_objects += dev->mode_config.num_bridge;
|
2008-11-07 22:05:41 +00:00
|
|
|
|
|
|
|
|
group->id_list = kzalloc(total_objects * sizeof(uint32_t), GFP_KERNEL);
|
|
|
|
|
if (!group->id_list)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
|
|
group->num_crtcs = 0;
|
|
|
|
|
group->num_connectors = 0;
|
|
|
|
|
group->num_encoders = 0;
|
2013-08-14 20:47:37 +00:00
|
|
|
group->num_bridges = 0;
|
2008-11-07 22:05:41 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2014-05-02 03:22:19 +00:00
|
|
|
void drm_mode_group_destroy(struct drm_mode_group *group)
|
|
|
|
|
{
|
|
|
|
|
kfree(group->id_list);
|
|
|
|
|
group->id_list = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2014-03-10 20:33:02 +00:00
|
|
|
/*
|
|
|
|
|
* NOTE: Driver's shouldn't ever call drm_mode_group_init_legacy_group - it is
|
|
|
|
|
* the drm core's responsibility to set up mode control groups.
|
|
|
|
|
*/
|
2008-11-07 22:05:41 +00:00
|
|
|
int drm_mode_group_init_legacy_group(struct drm_device *dev,
|
|
|
|
|
struct drm_mode_group *group)
|
|
|
|
|
{
|
|
|
|
|
struct drm_crtc *crtc;
|
|
|
|
|
struct drm_encoder *encoder;
|
|
|
|
|
struct drm_connector *connector;
|
2013-08-14 20:47:37 +00:00
|
|
|
struct drm_bridge *bridge;
|
2008-11-07 22:05:41 +00:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
|
|
if ((ret = drm_mode_group_init(dev, group)))
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
|
|
list_for_each_entry(crtc, &dev->mode_config.crtc_list, head)
|
|
|
|
|
group->id_list[group->num_crtcs++] = crtc->base.id;
|
|
|
|
|
|
|
|
|
|
list_for_each_entry(encoder, &dev->mode_config.encoder_list, head)
|
|
|
|
|
group->id_list[group->num_crtcs + group->num_encoders++] =
|
|
|
|
|
encoder->base.id;
|
|
|
|
|
|
|
|
|
|
list_for_each_entry(connector, &dev->mode_config.connector_list, head)
|
|
|
|
|
group->id_list[group->num_crtcs + group->num_encoders +
|
|
|
|
|
group->num_connectors++] = connector->base.id;
|
|
|
|
|
|
2013-08-14 20:47:37 +00:00
|
|
|
list_for_each_entry(bridge, &dev->mode_config.bridge_list, head)
|
|
|
|
|
group->id_list[group->num_crtcs + group->num_encoders +
|
|
|
|
|
group->num_connectors + group->num_bridges++] =
|
|
|
|
|
bridge->base.id;
|
|
|
|
|
|
2008-11-07 22:05:41 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
2012-03-20 06:59:29 +00:00
|
|
|
EXPORT_SYMBOL(drm_mode_group_init_legacy_group);
|
2008-11-07 22:05:41 +00:00
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* drm_crtc_convert_to_umode - convert a drm_display_mode into a modeinfo
|
|
|
|
|
* @out: drm_mode_modeinfo struct to return to the user
|
|
|
|
|
* @in: drm_display_mode to use
|
|
|
|
|
*
|
|
|
|
|
* Convert a drm_display_mode into a drm_mode_modeinfo structure to return to
|
|
|
|
|
* the user.
|
|
|
|
|
*/
|
2012-03-13 10:35:47 +00:00
|
|
|
static void drm_crtc_convert_to_umode(struct drm_mode_modeinfo *out,
|
|
|
|
|
const struct drm_display_mode *in)
|
2008-11-07 22:05:41 +00:00
|
|
|
{
|
2012-03-13 10:35:40 +00:00
|
|
|
WARN(in->hdisplay > USHRT_MAX || in->hsync_start > USHRT_MAX ||
|
|
|
|
|
in->hsync_end > USHRT_MAX || in->htotal > USHRT_MAX ||
|
|
|
|
|
in->hskew > USHRT_MAX || in->vdisplay > USHRT_MAX ||
|
|
|
|
|
in->vsync_start > USHRT_MAX || in->vsync_end > USHRT_MAX ||
|
|
|
|
|
in->vtotal > USHRT_MAX || in->vscan > USHRT_MAX,
|
|
|
|
|
"timing values too large for mode info\n");
|
|
|
|
|
|
2008-11-07 22:05:41 +00:00
|
|
|
out->clock = in->clock;
|
|
|
|
|
out->hdisplay = in->hdisplay;
|
|
|
|
|
out->hsync_start = in->hsync_start;
|
|
|
|
|
out->hsync_end = in->hsync_end;
|
|
|
|
|
out->htotal = in->htotal;
|
|
|
|
|
out->hskew = in->hskew;
|
|
|
|
|
out->vdisplay = in->vdisplay;
|
|
|
|
|
out->vsync_start = in->vsync_start;
|
|
|
|
|
out->vsync_end = in->vsync_end;
|
|
|
|
|
out->vtotal = in->vtotal;
|
|
|
|
|
out->vscan = in->vscan;
|
|
|
|
|
out->vrefresh = in->vrefresh;
|
|
|
|
|
out->flags = in->flags;
|
|
|
|
|
out->type = in->type;
|
|
|
|
|
strncpy(out->name, in->name, DRM_DISPLAY_MODE_LEN);
|
|
|
|
|
out->name[DRM_DISPLAY_MODE_LEN-1] = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
2013-10-18 14:11:27 +00:00
|
|
|
* drm_crtc_convert_umode - convert a modeinfo into a drm_display_mode
|
2008-11-07 22:05:41 +00:00
|
|
|
* @out: drm_display_mode to return to the user
|
|
|
|
|
* @in: drm_mode_modeinfo to use
|
|
|
|
|
*
|
|
|
|
|
* Convert a drm_mode_modeinfo into a drm_display_mode structure to return to
|
|
|
|
|
* the caller.
|
2012-03-13 10:35:44 +00:00
|
|
|
*
|
2014-03-10 20:33:02 +00:00
|
|
|
* Returns:
|
2012-03-13 10:35:44 +00:00
|
|
|
* Zero on success, errno on failure.
|
2008-11-07 22:05:41 +00:00
|
|
|
*/
|
2012-03-13 10:35:47 +00:00
|
|
|
static int drm_crtc_convert_umode(struct drm_display_mode *out,
|
|
|
|
|
const struct drm_mode_modeinfo *in)
|
2008-11-07 22:05:41 +00:00
|
|
|
{
|
2012-03-13 10:35:44 +00:00
|
|
|
if (in->clock > INT_MAX || in->vrefresh > INT_MAX)
|
|
|
|
|
return -ERANGE;
|
|
|
|
|
|
2013-09-27 11:11:50 +00:00
|
|
|
if ((in->flags & DRM_MODE_FLAG_3D_MASK) > DRM_MODE_FLAG_3D_MAX)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2008-11-07 22:05:41 +00:00
|
|
|
out->clock = in->clock;
|
|
|
|
|
out->hdisplay = in->hdisplay;
|
|
|
|
|
out->hsync_start = in->hsync_start;
|
|
|
|
|
out->hsync_end = in->hsync_end;
|
|
|
|
|
out->htotal = in->htotal;
|
|
|
|
|
out->hskew = in->hskew;
|
|
|
|
|
out->vdisplay = in->vdisplay;
|
|
|
|
|
out->vsync_start = in->vsync_start;
|
|
|
|
|
out->vsync_end = in->vsync_end;
|
|
|
|
|
out->vtotal = in->vtotal;
|
|
|
|
|
out->vscan = in->vscan;
|
|
|
|
|
out->vrefresh = in->vrefresh;
|
|
|
|
|
out->flags = in->flags;
|
|
|
|
|
out->type = in->type;
|
|
|
|
|
strncpy(out->name, in->name, DRM_DISPLAY_MODE_LEN);
|
|
|
|
|
out->name[DRM_DISPLAY_MODE_LEN-1] = 0;
|
2012-03-13 10:35:44 +00:00
|
|
|
|
|
|
|
|
return 0;
|
2008-11-07 22:05:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* drm_mode_getresources - get graphics configuration
|
2012-12-01 23:09:18 +00:00
|
|
|
* @dev: drm device for the ioctl
|
|
|
|
|
* @data: data pointer for the ioctl
|
|
|
|
|
* @file_priv: drm file for the ioctl call
|
2008-11-07 22:05:41 +00:00
|
|
|
*
|
|
|
|
|
* Construct a set of configuration description structures and return
|
|
|
|
|
* them to the user, including CRTC, connector and framebuffer configuration.
|
|
|
|
|
*
|
|
|
|
|
* Called by the user via ioctl.
|
|
|
|
|
*
|
2014-03-10 20:33:02 +00:00
|
|
|
* Returns:
|
2008-11-07 22:05:41 +00:00
|
|
|
* Zero on success, errno on failure.
|
|
|
|
|
*/
|
|
|
|
|
int drm_mode_getresources(struct drm_device *dev, void *data,
|
|
|
|
|
struct drm_file *file_priv)
|
|
|
|
|
{
|
|
|
|
|
struct drm_mode_card_res *card_res = data;
|
|
|
|
|
struct list_head *lh;
|
|
|
|
|
struct drm_framebuffer *fb;
|
|
|
|
|
struct drm_connector *connector;
|
|
|
|
|
struct drm_crtc *crtc;
|
|
|
|
|
struct drm_encoder *encoder;
|
|
|
|
|
int ret = 0;
|
|
|
|
|
int connector_count = 0;
|
|
|
|
|
int crtc_count = 0;
|
|
|
|
|
int fb_count = 0;
|
|
|
|
|
int encoder_count = 0;
|
|
|
|
|
int copied = 0, i;
|
|
|
|
|
uint32_t __user *fb_id;
|
|
|
|
|
uint32_t __user *crtc_id;
|
|
|
|
|
uint32_t __user *connector_id;
|
|
|
|
|
uint32_t __user *encoder_id;
|
|
|
|
|
struct drm_mode_group *mode_group;
|
|
|
|
|
|
2011-02-08 03:55:21 +00:00
|
|
|
if (!drm_core_check_feature(dev, DRIVER_MODESET))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2008-11-07 22:05:41 +00:00
|
|
|
|
drm: revamp locking around fb creation/destruction
Well, at least step 1. The goal here is that framebuffer objects can
survive outside of the mode_config lock, with just a reference held
as protection. The first step to get there is to introduce a special
fb_lock which protects fb lookup, creation and destruction, to make
them appear atomic.
This new fb_lock can nest within the mode_config lock. But the idea is
(once the reference counting part is completed) that we only quickly
take that fb_lock to lookup a framebuffer and grab a reference,
without any other locks involved.
vmwgfx is the only driver which does framebuffer lookups itself, also
wrap those calls to drm_mode_object_find with the new lock.
Also protect the fb_list walking in i915 and omapdrm with the new lock.
As a slight complication there's also the list of user-created fbs
attached to the file private. The problem now is that at fclose() time
we need to walk that list, eventually do a modeset call to remove the
fb from active usage (and are required to be able to take the
mode_config lock), but in the end we need to grab the new fb_lock to
remove the fb from the list. The easiest solution is to add another
mutex to protect this per-file list.
Currently that new fbs_lock nests within the modeset locks and so
appears redudant. But later patches will switch around this sequence
so that taking the modeset locks in the fb destruction path is
optional in the fastpath. Ultimately the goal is that addfb and rmfb
do not require the mode_config lock, since otherwise they have the
potential to introduce stalls in the pageflip sequence of a compositor
(if the compositor e.g. switches to a fullscreen client or if it
enables a plane). But that requires a few more steps and hoops to jump
through.
Note that framebuffer creation/destruction is now double-protected -
once by the fb_lock and in parts by the idr_lock. The later would be
unnecessariy if framebuffers would have their own idr allocator. But
that's material for another patch (series).
v2: Properly initialize the fb->filp_head list in _init, otherwise the
newly added WARN to check whether the fb isn't on a fpriv list any
more will fail for driver-private objects.
v3: Fixup two error-case unlock bugs spotted by Richard Wilbur.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-10 20:19:18 +00:00
|
|
|
mutex_lock(&file_priv->fbs_lock);
|
2008-11-07 22:05:41 +00:00
|
|
|
/*
|
|
|
|
|
* For the non-control nodes we need to limit the list of resources
|
|
|
|
|
* by IDs in the group list for this node
|
|
|
|
|
*/
|
|
|
|
|
list_for_each(lh, &file_priv->fbs)
|
|
|
|
|
fb_count++;
|
|
|
|
|
|
drm: revamp locking around fb creation/destruction
Well, at least step 1. The goal here is that framebuffer objects can
survive outside of the mode_config lock, with just a reference held
as protection. The first step to get there is to introduce a special
fb_lock which protects fb lookup, creation and destruction, to make
them appear atomic.
This new fb_lock can nest within the mode_config lock. But the idea is
(once the reference counting part is completed) that we only quickly
take that fb_lock to lookup a framebuffer and grab a reference,
without any other locks involved.
vmwgfx is the only driver which does framebuffer lookups itself, also
wrap those calls to drm_mode_object_find with the new lock.
Also protect the fb_list walking in i915 and omapdrm with the new lock.
As a slight complication there's also the list of user-created fbs
attached to the file private. The problem now is that at fclose() time
we need to walk that list, eventually do a modeset call to remove the
fb from active usage (and are required to be able to take the
mode_config lock), but in the end we need to grab the new fb_lock to
remove the fb from the list. The easiest solution is to add another
mutex to protect this per-file list.
Currently that new fbs_lock nests within the modeset locks and so
appears redudant. But later patches will switch around this sequence
so that taking the modeset locks in the fb destruction path is
optional in the fastpath. Ultimately the goal is that addfb and rmfb
do not require the mode_config lock, since otherwise they have the
potential to introduce stalls in the pageflip sequence of a compositor
(if the compositor e.g. switches to a fullscreen client or if it
enables a plane). But that requires a few more steps and hoops to jump
through.
Note that framebuffer creation/destruction is now double-protected -
once by the fb_lock and in parts by the idr_lock. The later would be
unnecessariy if framebuffers would have their own idr allocator. But
that's material for another patch (series).
v2: Properly initialize the fb->filp_head list in _init, otherwise the
newly added WARN to check whether the fb isn't on a fpriv list any
more will fail for driver-private objects.
v3: Fixup two error-case unlock bugs spotted by Richard Wilbur.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-10 20:19:18 +00:00
|
|
|
/* handle this in 4 parts */
|
|
|
|
|
/* FBs */
|
|
|
|
|
if (card_res->count_fbs >= fb_count) {
|
|
|
|
|
copied = 0;
|
|
|
|
|
fb_id = (uint32_t __user *)(unsigned long)card_res->fb_id_ptr;
|
|
|
|
|
list_for_each_entry(fb, &file_priv->fbs, filp_head) {
|
|
|
|
|
if (put_user(fb->base.id, fb_id + copied)) {
|
|
|
|
|
mutex_unlock(&file_priv->fbs_lock);
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
}
|
|
|
|
|
copied++;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
card_res->count_fbs = fb_count;
|
|
|
|
|
mutex_unlock(&file_priv->fbs_lock);
|
|
|
|
|
|
|
|
|
|
drm_modeset_lock_all(dev);
|
2014-03-13 10:07:44 +00:00
|
|
|
if (!drm_is_primary_client(file_priv)) {
|
2008-11-07 22:05:41 +00:00
|
|
|
|
2014-03-13 09:00:42 +00:00
|
|
|
mode_group = NULL;
|
2008-11-07 22:05:41 +00:00
|
|
|
list_for_each(lh, &dev->mode_config.crtc_list)
|
|
|
|
|
crtc_count++;
|
|
|
|
|
|
|
|
|
|
list_for_each(lh, &dev->mode_config.connector_list)
|
|
|
|
|
connector_count++;
|
|
|
|
|
|
|
|
|
|
list_for_each(lh, &dev->mode_config.encoder_list)
|
|
|
|
|
encoder_count++;
|
|
|
|
|
} else {
|
|
|
|
|
|
2014-03-13 09:00:42 +00:00
|
|
|
mode_group = &file_priv->master->minor->mode_group;
|
2008-11-07 22:05:41 +00:00
|
|
|
crtc_count = mode_group->num_crtcs;
|
|
|
|
|
connector_count = mode_group->num_connectors;
|
|
|
|
|
encoder_count = mode_group->num_encoders;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
card_res->max_height = dev->mode_config.max_height;
|
|
|
|
|
card_res->min_height = dev->mode_config.min_height;
|
|
|
|
|
card_res->max_width = dev->mode_config.max_width;
|
|
|
|
|
card_res->min_width = dev->mode_config.min_width;
|
|
|
|
|
|
|
|
|
|
/* CRTCs */
|
|
|
|
|
if (card_res->count_crtcs >= crtc_count) {
|
|
|
|
|
copied = 0;
|
|
|
|
|
crtc_id = (uint32_t __user *)(unsigned long)card_res->crtc_id_ptr;
|
2014-03-13 09:00:42 +00:00
|
|
|
if (!mode_group) {
|
2008-11-07 22:05:41 +00:00
|
|
|
list_for_each_entry(crtc, &dev->mode_config.crtc_list,
|
|
|
|
|
head) {
|
2010-07-15 19:43:25 +00:00
|
|
|
DRM_DEBUG_KMS("[CRTC:%d]\n", crtc->base.id);
|
2008-11-07 22:05:41 +00:00
|
|
|
if (put_user(crtc->base.id, crtc_id + copied)) {
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
copied++;
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
for (i = 0; i < mode_group->num_crtcs; i++) {
|
|
|
|
|
if (put_user(mode_group->id_list[i],
|
|
|
|
|
crtc_id + copied)) {
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
copied++;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
card_res->count_crtcs = crtc_count;
|
|
|
|
|
|
|
|
|
|
/* Encoders */
|
|
|
|
|
if (card_res->count_encoders >= encoder_count) {
|
|
|
|
|
copied = 0;
|
|
|
|
|
encoder_id = (uint32_t __user *)(unsigned long)card_res->encoder_id_ptr;
|
2014-03-13 09:00:42 +00:00
|
|
|
if (!mode_group) {
|
2008-11-07 22:05:41 +00:00
|
|
|
list_for_each_entry(encoder,
|
|
|
|
|
&dev->mode_config.encoder_list,
|
|
|
|
|
head) {
|
2010-07-15 19:43:25 +00:00
|
|
|
DRM_DEBUG_KMS("[ENCODER:%d:%s]\n", encoder->base.id,
|
2014-06-03 11:56:22 +00:00
|
|
|
encoder->name);
|
2008-11-07 22:05:41 +00:00
|
|
|
if (put_user(encoder->base.id, encoder_id +
|
|
|
|
|
copied)) {
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
copied++;
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
for (i = mode_group->num_crtcs; i < mode_group->num_crtcs + mode_group->num_encoders; i++) {
|
|
|
|
|
if (put_user(mode_group->id_list[i],
|
|
|
|
|
encoder_id + copied)) {
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
copied++;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
card_res->count_encoders = encoder_count;
|
|
|
|
|
|
|
|
|
|
/* Connectors */
|
|
|
|
|
if (card_res->count_connectors >= connector_count) {
|
|
|
|
|
copied = 0;
|
|
|
|
|
connector_id = (uint32_t __user *)(unsigned long)card_res->connector_id_ptr;
|
2014-03-13 09:00:42 +00:00
|
|
|
if (!mode_group) {
|
2008-11-07 22:05:41 +00:00
|
|
|
list_for_each_entry(connector,
|
|
|
|
|
&dev->mode_config.connector_list,
|
|
|
|
|
head) {
|
2010-07-15 19:43:25 +00:00
|
|
|
DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n",
|
|
|
|
|
connector->base.id,
|
2014-06-03 11:56:20 +00:00
|
|
|
connector->name);
|
2008-11-07 22:05:41 +00:00
|
|
|
if (put_user(connector->base.id,
|
|
|
|
|
connector_id + copied)) {
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
copied++;
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
int start = mode_group->num_crtcs +
|
|
|
|
|
mode_group->num_encoders;
|
|
|
|
|
for (i = start; i < start + mode_group->num_connectors; i++) {
|
|
|
|
|
if (put_user(mode_group->id_list[i],
|
|
|
|
|
connector_id + copied)) {
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
copied++;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
card_res->count_connectors = connector_count;
|
|
|
|
|
|
2010-07-15 19:43:25 +00:00
|
|
|
DRM_DEBUG_KMS("CRTC[%d] CONNECTORS[%d] ENCODERS[%d]\n", card_res->count_crtcs,
|
2008-11-07 22:05:41 +00:00
|
|
|
card_res->count_connectors, card_res->count_encoders);
|
|
|
|
|
|
|
|
|
|
out:
|
2012-12-01 23:28:11 +00:00
|
|
|
drm_modeset_unlock_all(dev);
|
2008-11-07 22:05:41 +00:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* drm_mode_getcrtc - get CRTC configuration
|
2012-12-01 23:09:18 +00:00
|
|
|
* @dev: drm device for the ioctl
|
|
|
|
|
* @data: data pointer for the ioctl
|
|
|
|
|
* @file_priv: drm file for the ioctl call
|
2008-11-07 22:05:41 +00:00
|
|
|
*
|
|
|
|
|
* Construct a CRTC configuration structure to return to the user.
|
|
|
|
|
*
|
|
|
|
|
* Called by the user via ioctl.
|
|
|
|
|
*
|
2014-03-10 20:33:02 +00:00
|
|
|
* Returns:
|
2008-11-07 22:05:41 +00:00
|
|
|
* Zero on success, errno on failure.
|
|
|
|
|
*/
|
|
|
|
|
int drm_mode_getcrtc(struct drm_device *dev,
|
|
|
|
|
void *data, struct drm_file *file_priv)
|
|
|
|
|
{
|
|
|
|
|
struct drm_mode_crtc *crtc_resp = data;
|
|
|
|
|
struct drm_crtc *crtc;
|
|
|
|
|
int ret = 0;
|
|
|
|
|
|
2011-02-08 03:55:21 +00:00
|
|
|
if (!drm_core_check_feature(dev, DRIVER_MODESET))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2012-12-01 23:28:11 +00:00
|
|
|
drm_modeset_lock_all(dev);
|
2008-11-07 22:05:41 +00:00
|
|
|
|
2013-10-05 20:36:52 +00:00
|
|
|
crtc = drm_crtc_find(dev, crtc_resp->crtc_id);
|
|
|
|
|
if (!crtc) {
|
2013-10-17 10:35:00 +00:00
|
|
|
ret = -ENOENT;
|
2008-11-07 22:05:41 +00:00
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
crtc_resp->x = crtc->x;
|
|
|
|
|
crtc_resp->y = crtc->y;
|
|
|
|
|
crtc_resp->gamma_size = crtc->gamma_size;
|
2014-04-01 22:22:40 +00:00
|
|
|
if (crtc->primary->fb)
|
|
|
|
|
crtc_resp->fb_id = crtc->primary->fb->base.id;
|
2008-11-07 22:05:41 +00:00
|
|
|
else
|
|
|
|
|
crtc_resp->fb_id = 0;
|
|
|
|
|
|
|
|
|
|
if (crtc->enabled) {
|
|
|
|
|
|
|
|
|
|
drm_crtc_convert_to_umode(&crtc_resp->mode, &crtc->mode);
|
|
|
|
|
crtc_resp->mode_valid = 1;
|
|
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
crtc_resp->mode_valid = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
out:
|
2012-12-01 23:28:11 +00:00
|
|
|
drm_modeset_unlock_all(dev);
|
2008-11-07 22:05:41 +00:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2013-09-25 15:45:22 +00:00
|
|
|
static bool drm_mode_expose_to_userspace(const struct drm_display_mode *mode,
|
|
|
|
|
const struct drm_file *file_priv)
|
|
|
|
|
{
|
|
|
|
|
/*
|
|
|
|
|
* If user-space hasn't configured the driver to expose the stereo 3D
|
|
|
|
|
* modes, don't expose them.
|
|
|
|
|
*/
|
|
|
|
|
if (!file_priv->stereo_allowed && drm_mode_is_stereo(mode))
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
2008-11-07 22:05:41 +00:00
|
|
|
/**
|
|
|
|
|
* drm_mode_getconnector - get connector configuration
|
2012-12-01 23:09:18 +00:00
|
|
|
* @dev: drm device for the ioctl
|
|
|
|
|
* @data: data pointer for the ioctl
|
|
|
|
|
* @file_priv: drm file for the ioctl call
|
2008-11-07 22:05:41 +00:00
|
|
|
*
|
|
|
|
|
* Construct a connector configuration structure to return to the user.
|
|
|
|
|
*
|
|
|
|
|
* Called by the user via ioctl.
|
|
|
|
|
*
|
2014-03-10 20:33:02 +00:00
|
|
|
* Returns:
|
2008-11-07 22:05:41 +00:00
|
|
|
* Zero on success, errno on failure.
|
|
|
|
|
*/
|
|
|
|
|
int drm_mode_getconnector(struct drm_device *dev, void *data,
|
|
|
|
|
struct drm_file *file_priv)
|
|
|
|
|
{
|
|
|
|
|
struct drm_mode_get_connector *out_resp = data;
|
|
|
|
|
struct drm_connector *connector;
|
|
|
|
|
struct drm_display_mode *mode;
|
|
|
|
|
int mode_count = 0;
|
|
|
|
|
int props_count = 0;
|
|
|
|
|
int encoders_count = 0;
|
|
|
|
|
int ret = 0;
|
|
|
|
|
int copied = 0;
|
|
|
|
|
int i;
|
|
|
|
|
struct drm_mode_modeinfo u_mode;
|
|
|
|
|
struct drm_mode_modeinfo __user *mode_ptr;
|
|
|
|
|
uint32_t __user *prop_ptr;
|
|
|
|
|
uint64_t __user *prop_values;
|
|
|
|
|
uint32_t __user *encoder_ptr;
|
|
|
|
|
|
2011-02-08 03:55:21 +00:00
|
|
|
if (!drm_core_check_feature(dev, DRIVER_MODESET))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2008-11-07 22:05:41 +00:00
|
|
|
memset(&u_mode, 0, sizeof(struct drm_mode_modeinfo));
|
|
|
|
|
|
2010-07-15 19:43:25 +00:00
|
|
|
DRM_DEBUG_KMS("[CONNECTOR:%d:?]\n", out_resp->connector_id);
|
2008-11-07 22:05:41 +00:00
|
|
|
|
2012-12-11 23:35:33 +00:00
|
|
|
mutex_lock(&dev->mode_config.mutex);
|
2013-11-19 17:10:12 +00:00
|
|
|
drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
|
2008-11-07 22:05:41 +00:00
|
|
|
|
2013-10-05 20:36:52 +00:00
|
|
|
connector = drm_connector_find(dev, out_resp->connector_id);
|
|
|
|
|
if (!connector) {
|
2013-10-17 10:35:00 +00:00
|
|
|
ret = -ENOENT;
|
2008-11-07 22:05:41 +00:00
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
2012-05-15 21:09:04 +00:00
|
|
|
props_count = connector->properties.count;
|
2008-11-07 22:05:41 +00:00
|
|
|
|
|
|
|
|
for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
|
|
|
|
|
if (connector->encoder_ids[i] != 0) {
|
|
|
|
|
encoders_count++;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (out_resp->count_modes == 0) {
|
|
|
|
|
connector->funcs->fill_modes(connector,
|
|
|
|
|
dev->mode_config.max_width,
|
|
|
|
|
dev->mode_config.max_height);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* delayed so we get modes regardless of pre-fill_modes state */
|
|
|
|
|
list_for_each_entry(mode, &connector->modes, head)
|
2013-09-25 15:45:22 +00:00
|
|
|
if (drm_mode_expose_to_userspace(mode, file_priv))
|
|
|
|
|
mode_count++;
|
2008-11-07 22:05:41 +00:00
|
|
|
|
|
|
|
|
out_resp->connector_id = connector->base.id;
|
|
|
|
|
out_resp->connector_type = connector->connector_type;
|
|
|
|
|
out_resp->connector_type_id = connector->connector_type_id;
|
|
|
|
|
out_resp->mm_width = connector->display_info.width_mm;
|
|
|
|
|
out_resp->mm_height = connector->display_info.height_mm;
|
|
|
|
|
out_resp->subpixel = connector->display_info.subpixel_order;
|
|
|
|
|
out_resp->connection = connector->status;
|
|
|
|
|
if (connector->encoder)
|
|
|
|
|
out_resp->encoder_id = connector->encoder->base.id;
|
|
|
|
|
else
|
|
|
|
|
out_resp->encoder_id = 0;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* This ioctl is called twice, once to determine how much space is
|
|
|
|
|
* needed, and the 2nd time to fill it.
|
|
|
|
|
*/
|
|
|
|
|
if ((out_resp->count_modes >= mode_count) && mode_count) {
|
|
|
|
|
copied = 0;
|
2011-12-19 22:06:42 +00:00
|
|
|
mode_ptr = (struct drm_mode_modeinfo __user *)(unsigned long)out_resp->modes_ptr;
|
2008-11-07 22:05:41 +00:00
|
|
|
list_for_each_entry(mode, &connector->modes, head) {
|
2013-09-25 15:45:22 +00:00
|
|
|
if (!drm_mode_expose_to_userspace(mode, file_priv))
|
|
|
|
|
continue;
|
|
|
|
|
|
2008-11-07 22:05:41 +00:00
|
|
|
drm_crtc_convert_to_umode(&u_mode, mode);
|
|
|
|
|
if (copy_to_user(mode_ptr + copied,
|
|
|
|
|
&u_mode, sizeof(u_mode))) {
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
copied++;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
out_resp->count_modes = mode_count;
|
|
|
|
|
|
|
|
|
|
if ((out_resp->count_props >= props_count) && props_count) {
|
|
|
|
|
copied = 0;
|
2011-12-19 22:06:42 +00:00
|
|
|
prop_ptr = (uint32_t __user *)(unsigned long)(out_resp->props_ptr);
|
|
|
|
|
prop_values = (uint64_t __user *)(unsigned long)(out_resp->prop_values_ptr);
|
2012-05-15 21:09:04 +00:00
|
|
|
for (i = 0; i < connector->properties.count; i++) {
|
|
|
|
|
if (put_user(connector->properties.ids[i],
|
|
|
|
|
prop_ptr + copied)) {
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
2008-11-07 22:05:41 +00:00
|
|
|
|
2012-05-15 21:09:04 +00:00
|
|
|
if (put_user(connector->properties.values[i],
|
|
|
|
|
prop_values + copied)) {
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
goto out;
|
2008-11-07 22:05:41 +00:00
|
|
|
}
|
2012-05-15 21:09:04 +00:00
|
|
|
copied++;
|
2008-11-07 22:05:41 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
out_resp->count_props = props_count;
|
|
|
|
|
|
|
|
|
|
if ((out_resp->count_encoders >= encoders_count) && encoders_count) {
|
|
|
|
|
copied = 0;
|
2011-12-19 22:06:42 +00:00
|
|
|
encoder_ptr = (uint32_t __user *)(unsigned long)(out_resp->encoders_ptr);
|
2008-11-07 22:05:41 +00:00
|
|
|
for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
|
|
|
|
|
if (connector->encoder_ids[i] != 0) {
|
|
|
|
|
if (put_user(connector->encoder_ids[i],
|
|
|
|
|
encoder_ptr + copied)) {
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
copied++;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
out_resp->count_encoders = encoders_count;
|
|
|
|
|
|
|
|
|
|
out:
|
2013-11-19 17:10:12 +00:00
|
|
|
drm_modeset_unlock(&dev->mode_config.connection_mutex);
|
2012-12-11 23:35:33 +00:00
|
|
|
mutex_unlock(&dev->mode_config.mutex);
|
|
|
|
|
|
2008-11-07 22:05:41 +00:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2014-03-10 20:33:02 +00:00
|
|
|
/**
|
|
|
|
|
* drm_mode_getencoder - get encoder configuration
|
|
|
|
|
* @dev: drm device for the ioctl
|
|
|
|
|
* @data: data pointer for the ioctl
|
|
|
|
|
* @file_priv: drm file for the ioctl call
|
|
|
|
|
*
|
|
|
|
|
* Construct a encoder configuration structure to return to the user.
|
|
|
|
|
*
|
|
|
|
|
* Called by the user via ioctl.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* Zero on success, errno on failure.
|
|
|
|
|
*/
|
2008-11-07 22:05:41 +00:00
|
|
|
int drm_mode_getencoder(struct drm_device *dev, void *data,
|
|
|
|
|
struct drm_file *file_priv)
|
|
|
|
|
{
|
|
|
|
|
struct drm_mode_get_encoder *enc_resp = data;
|
|
|
|
|
struct drm_encoder *encoder;
|
|
|
|
|
int ret = 0;
|
|
|
|
|
|
2011-02-08 03:55:21 +00:00
|
|
|
if (!drm_core_check_feature(dev, DRIVER_MODESET))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2012-12-01 23:28:11 +00:00
|
|
|
drm_modeset_lock_all(dev);
|
2013-10-05 20:36:52 +00:00
|
|
|
encoder = drm_encoder_find(dev, enc_resp->encoder_id);
|
|
|
|
|
if (!encoder) {
|
2013-10-17 10:35:00 +00:00
|
|
|
ret = -ENOENT;
|
2008-11-07 22:05:41 +00:00
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (encoder->crtc)
|
|
|
|
|
enc_resp->crtc_id = encoder->crtc->base.id;
|
|
|
|
|
else
|
|
|
|
|
enc_resp->crtc_id = 0;
|
|
|
|
|
enc_resp->encoder_type = encoder->encoder_type;
|
|
|
|
|
enc_resp->encoder_id = encoder->base.id;
|
|
|
|
|
enc_resp->possible_crtcs = encoder->possible_crtcs;
|
|
|
|
|
enc_resp->possible_clones = encoder->possible_clones;
|
|
|
|
|
|
|
|
|
|
out:
|
2012-12-01 23:28:11 +00:00
|
|
|
drm_modeset_unlock_all(dev);
|
2008-11-07 22:05:41 +00:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2011-11-14 22:51:27 +00:00
|
|
|
/**
|
2014-03-10 20:33:02 +00:00
|
|
|
* drm_mode_getplane_res - enumerate all plane resources
|
2011-11-14 22:51:27 +00:00
|
|
|
* @dev: DRM device
|
|
|
|
|
* @data: ioctl data
|
|
|
|
|
* @file_priv: DRM file info
|
|
|
|
|
*
|
2014-03-10 20:33:02 +00:00
|
|
|
* Construct a list of plane ids to return to the user.
|
|
|
|
|
*
|
|
|
|
|
* Called by the user via ioctl.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* Zero on success, errno on failure.
|
2011-11-14 22:51:27 +00:00
|
|
|
*/
|
|
|
|
|
int drm_mode_getplane_res(struct drm_device *dev, void *data,
|
2014-03-10 20:33:02 +00:00
|
|
|
struct drm_file *file_priv)
|
2011-11-14 22:51:27 +00:00
|
|
|
{
|
|
|
|
|
struct drm_mode_get_plane_res *plane_resp = data;
|
|
|
|
|
struct drm_mode_config *config;
|
|
|
|
|
struct drm_plane *plane;
|
|
|
|
|
uint32_t __user *plane_ptr;
|
|
|
|
|
int copied = 0, ret = 0;
|
2014-04-01 22:22:42 +00:00
|
|
|
unsigned num_planes;
|
2011-11-14 22:51:27 +00:00
|
|
|
|
|
|
|
|
if (!drm_core_check_feature(dev, DRIVER_MODESET))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2012-12-01 23:28:11 +00:00
|
|
|
drm_modeset_lock_all(dev);
|
2011-11-14 22:51:27 +00:00
|
|
|
config = &dev->mode_config;
|
|
|
|
|
|
2014-04-01 22:22:42 +00:00
|
|
|
if (file_priv->universal_planes)
|
|
|
|
|
num_planes = config->num_total_plane;
|
|
|
|
|
else
|
|
|
|
|
num_planes = config->num_overlay_plane;
|
|
|
|
|
|
2011-11-14 22:51:27 +00:00
|
|
|
/*
|
|
|
|
|
* This ioctl is called twice, once to determine how much space is
|
|
|
|
|
* needed, and the 2nd time to fill it.
|
|
|
|
|
*/
|
2014-04-01 22:22:42 +00:00
|
|
|
if (num_planes &&
|
|
|
|
|
(plane_resp->count_planes >= num_planes)) {
|
2011-12-19 22:06:42 +00:00
|
|
|
plane_ptr = (uint32_t __user *)(unsigned long)plane_resp->plane_id_ptr;
|
2011-11-14 22:51:27 +00:00
|
|
|
|
|
|
|
|
list_for_each_entry(plane, &config->plane_list, head) {
|
2014-04-01 22:22:42 +00:00
|
|
|
/*
|
|
|
|
|
* Unless userspace set the 'universal planes'
|
|
|
|
|
* capability bit, only advertise overlays.
|
|
|
|
|
*/
|
|
|
|
|
if (plane->type != DRM_PLANE_TYPE_OVERLAY &&
|
|
|
|
|
!file_priv->universal_planes)
|
2014-04-01 22:22:30 +00:00
|
|
|
continue;
|
|
|
|
|
|
2011-11-14 22:51:27 +00:00
|
|
|
if (put_user(plane->base.id, plane_ptr + copied)) {
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
copied++;
|
|
|
|
|
}
|
|
|
|
|
}
|
2014-04-01 22:22:42 +00:00
|
|
|
plane_resp->count_planes = num_planes;
|
2011-11-14 22:51:27 +00:00
|
|
|
|
|
|
|
|
out:
|
2012-12-01 23:28:11 +00:00
|
|
|
drm_modeset_unlock_all(dev);
|
2011-11-14 22:51:27 +00:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
2014-03-10 20:33:02 +00:00
|
|
|
* drm_mode_getplane - get plane configuration
|
2011-11-14 22:51:27 +00:00
|
|
|
* @dev: DRM device
|
|
|
|
|
* @data: ioctl data
|
|
|
|
|
* @file_priv: DRM file info
|
|
|
|
|
*
|
2014-03-10 20:33:02 +00:00
|
|
|
* Construct a plane configuration structure to return to the user.
|
|
|
|
|
*
|
|
|
|
|
* Called by the user via ioctl.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* Zero on success, errno on failure.
|
2011-11-14 22:51:27 +00:00
|
|
|
*/
|
|
|
|
|
int drm_mode_getplane(struct drm_device *dev, void *data,
|
2014-03-10 20:33:02 +00:00
|
|
|
struct drm_file *file_priv)
|
2011-11-14 22:51:27 +00:00
|
|
|
{
|
|
|
|
|
struct drm_mode_get_plane *plane_resp = data;
|
|
|
|
|
struct drm_plane *plane;
|
|
|
|
|
uint32_t __user *format_ptr;
|
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
|
|
if (!drm_core_check_feature(dev, DRIVER_MODESET))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2012-12-01 23:28:11 +00:00
|
|
|
drm_modeset_lock_all(dev);
|
2013-10-05 20:36:52 +00:00
|
|
|
plane = drm_plane_find(dev, plane_resp->plane_id);
|
|
|
|
|
if (!plane) {
|
2011-11-14 22:51:27 +00:00
|
|
|
ret = -ENOENT;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (plane->crtc)
|
|
|
|
|
plane_resp->crtc_id = plane->crtc->base.id;
|
|
|
|
|
else
|
|
|
|
|
plane_resp->crtc_id = 0;
|
|
|
|
|
|
|
|
|
|
if (plane->fb)
|
|
|
|
|
plane_resp->fb_id = plane->fb->base.id;
|
|
|
|
|
else
|
|
|
|
|
plane_resp->fb_id = 0;
|
|
|
|
|
|
|
|
|
|
plane_resp->plane_id = plane->base.id;
|
|
|
|
|
plane_resp->possible_crtcs = plane->possible_crtcs;
|
2013-06-03 13:11:42 +00:00
|
|
|
plane_resp->gamma_size = 0;
|
2011-11-14 22:51:27 +00:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* This ioctl is called twice, once to determine how much space is
|
|
|
|
|
* needed, and the 2nd time to fill it.
|
|
|
|
|
*/
|
|
|
|
|
if (plane->format_count &&
|
|
|
|
|
(plane_resp->count_format_types >= plane->format_count)) {
|
2011-12-19 22:06:42 +00:00
|
|
|
format_ptr = (uint32_t __user *)(unsigned long)plane_resp->format_type_ptr;
|
2011-11-14 22:51:27 +00:00
|
|
|
if (copy_to_user(format_ptr,
|
|
|
|
|
plane->format_types,
|
|
|
|
|
sizeof(uint32_t) * plane->format_count)) {
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
plane_resp->count_format_types = plane->format_count;
|
|
|
|
|
|
|
|
|
|
out:
|
2012-12-01 23:28:11 +00:00
|
|
|
drm_modeset_unlock_all(dev);
|
2011-11-14 22:51:27 +00:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
2014-03-10 20:33:02 +00:00
|
|
|
* drm_mode_setplane - configure a plane's configuration
|
2011-11-14 22:51:27 +00:00
|
|
|
* @dev: DRM device
|
|
|
|
|
* @data: ioctl data*
|
2012-12-01 23:09:18 +00:00
|
|
|
* @file_priv: DRM file info
|
2011-11-14 22:51:27 +00:00
|
|
|
*
|
2014-03-10 20:33:02 +00:00
|
|
|
* Set plane configuration, including placement, fb, scaling, and other factors.
|
2011-11-14 22:51:27 +00:00
|
|
|
* Or pass a NULL fb to disable.
|
2014-03-10 20:33:02 +00:00
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* Zero on success, errno on failure.
|
2011-11-14 22:51:27 +00:00
|
|
|
*/
|
|
|
|
|
int drm_mode_setplane(struct drm_device *dev, void *data,
|
2014-03-10 20:33:02 +00:00
|
|
|
struct drm_file *file_priv)
|
2011-11-14 22:51:27 +00:00
|
|
|
{
|
|
|
|
|
struct drm_mode_set_plane *plane_req = data;
|
|
|
|
|
struct drm_plane *plane;
|
|
|
|
|
struct drm_crtc *crtc;
|
2012-12-10 23:59:24 +00:00
|
|
|
struct drm_framebuffer *fb = NULL, *old_fb = NULL;
|
2011-11-14 22:51:27 +00:00
|
|
|
int ret = 0;
|
2011-12-19 22:06:44 +00:00
|
|
|
unsigned int fb_width, fb_height;
|
2011-12-19 22:06:47 +00:00
|
|
|
int i;
|
2011-11-14 22:51:27 +00:00
|
|
|
|
|
|
|
|
if (!drm_core_check_feature(dev, DRIVER_MODESET))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* First, find the plane, crtc, and fb objects. If not available,
|
|
|
|
|
* we don't bother to call the driver.
|
|
|
|
|
*/
|
2013-10-05 20:36:52 +00:00
|
|
|
plane = drm_plane_find(dev, plane_req->plane_id);
|
|
|
|
|
if (!plane) {
|
2011-11-14 22:51:27 +00:00
|
|
|
DRM_DEBUG_KMS("Unknown plane ID %d\n",
|
|
|
|
|
plane_req->plane_id);
|
2012-12-10 23:59:24 +00:00
|
|
|
return -ENOENT;
|
2011-11-14 22:51:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* No fb means shut it down */
|
|
|
|
|
if (!plane_req->fb_id) {
|
2012-12-10 23:59:24 +00:00
|
|
|
drm_modeset_lock_all(dev);
|
|
|
|
|
old_fb = plane->fb;
|
2014-04-23 08:24:11 +00:00
|
|
|
ret = plane->funcs->disable_plane(plane);
|
|
|
|
|
if (!ret) {
|
|
|
|
|
plane->crtc = NULL;
|
|
|
|
|
plane->fb = NULL;
|
|
|
|
|
} else {
|
|
|
|
|
old_fb = NULL;
|
|
|
|
|
}
|
2012-12-10 23:59:24 +00:00
|
|
|
drm_modeset_unlock_all(dev);
|
2011-11-14 22:51:27 +00:00
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
2013-10-05 20:36:52 +00:00
|
|
|
crtc = drm_crtc_find(dev, plane_req->crtc_id);
|
|
|
|
|
if (!crtc) {
|
2011-11-14 22:51:27 +00:00
|
|
|
DRM_DEBUG_KMS("Unknown crtc ID %d\n",
|
|
|
|
|
plane_req->crtc_id);
|
|
|
|
|
ret = -ENOENT;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
2012-12-02 20:53:40 +00:00
|
|
|
fb = drm_framebuffer_lookup(dev, plane_req->fb_id);
|
|
|
|
|
if (!fb) {
|
2011-11-14 22:51:27 +00:00
|
|
|
DRM_DEBUG_KMS("Unknown framebuffer ID %d\n",
|
|
|
|
|
plane_req->fb_id);
|
|
|
|
|
ret = -ENOENT;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
2011-12-19 22:06:47 +00:00
|
|
|
/* Check whether this plane supports the fb pixel format. */
|
|
|
|
|
for (i = 0; i < plane->format_count; i++)
|
|
|
|
|
if (fb->pixel_format == plane->format_types[i])
|
|
|
|
|
break;
|
|
|
|
|
if (i == plane->format_count) {
|
2013-06-10 08:15:10 +00:00
|
|
|
DRM_DEBUG_KMS("Invalid pixel format %s\n",
|
|
|
|
|
drm_get_format_name(fb->pixel_format));
|
2011-12-19 22:06:47 +00:00
|
|
|
ret = -EINVAL;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
2011-12-19 22:06:44 +00:00
|
|
|
fb_width = fb->width << 16;
|
|
|
|
|
fb_height = fb->height << 16;
|
|
|
|
|
|
|
|
|
|
/* Make sure source coordinates are inside the fb. */
|
|
|
|
|
if (plane_req->src_w > fb_width ||
|
|
|
|
|
plane_req->src_x > fb_width - plane_req->src_w ||
|
|
|
|
|
plane_req->src_h > fb_height ||
|
|
|
|
|
plane_req->src_y > fb_height - plane_req->src_h) {
|
|
|
|
|
DRM_DEBUG_KMS("Invalid source coordinates "
|
|
|
|
|
"%u.%06ux%u.%06u+%u.%06u+%u.%06u\n",
|
|
|
|
|
plane_req->src_w >> 16,
|
|
|
|
|
((plane_req->src_w & 0xffff) * 15625) >> 10,
|
|
|
|
|
plane_req->src_h >> 16,
|
|
|
|
|
((plane_req->src_h & 0xffff) * 15625) >> 10,
|
|
|
|
|
plane_req->src_x >> 16,
|
|
|
|
|
((plane_req->src_x & 0xffff) * 15625) >> 10,
|
|
|
|
|
plane_req->src_y >> 16,
|
|
|
|
|
((plane_req->src_y & 0xffff) * 15625) >> 10);
|
|
|
|
|
ret = -ENOSPC;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
2011-12-19 22:06:45 +00:00
|
|
|
/* Give drivers some help against integer overflows */
|
|
|
|
|
if (plane_req->crtc_w > INT_MAX ||
|
|
|
|
|
plane_req->crtc_x > INT_MAX - (int32_t) plane_req->crtc_w ||
|
|
|
|
|
plane_req->crtc_h > INT_MAX ||
|
|
|
|
|
plane_req->crtc_y > INT_MAX - (int32_t) plane_req->crtc_h) {
|
|
|
|
|
DRM_DEBUG_KMS("Invalid CRTC coordinates %ux%u+%d+%d\n",
|
|
|
|
|
plane_req->crtc_w, plane_req->crtc_h,
|
|
|
|
|
plane_req->crtc_x, plane_req->crtc_y);
|
|
|
|
|
ret = -ERANGE;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
2012-12-10 23:59:24 +00:00
|
|
|
drm_modeset_lock_all(dev);
|
2014-04-23 15:34:06 +00:00
|
|
|
old_fb = plane->fb;
|
2011-11-14 22:51:27 +00:00
|
|
|
ret = plane->funcs->update_plane(plane, crtc, fb,
|
|
|
|
|
plane_req->crtc_x, plane_req->crtc_y,
|
|
|
|
|
plane_req->crtc_w, plane_req->crtc_h,
|
|
|
|
|
plane_req->src_x, plane_req->src_y,
|
|
|
|
|
plane_req->src_w, plane_req->src_h);
|
|
|
|
|
if (!ret) {
|
|
|
|
|
plane->crtc = crtc;
|
|
|
|
|
plane->fb = fb;
|
2013-02-15 20:21:37 +00:00
|
|
|
fb = NULL;
|
2014-04-23 15:34:06 +00:00
|
|
|
} else {
|
|
|
|
|
old_fb = NULL;
|
2011-11-14 22:51:27 +00:00
|
|
|
}
|
2012-12-10 23:59:24 +00:00
|
|
|
drm_modeset_unlock_all(dev);
|
2011-11-14 22:51:27 +00:00
|
|
|
|
|
|
|
|
out:
|
2012-12-10 23:59:24 +00:00
|
|
|
if (fb)
|
|
|
|
|
drm_framebuffer_unreference(fb);
|
|
|
|
|
if (old_fb)
|
|
|
|
|
drm_framebuffer_unreference(old_fb);
|
2011-11-14 22:51:27 +00:00
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2012-12-11 12:47:23 +00:00
|
|
|
/**
|
|
|
|
|
* drm_mode_set_config_internal - helper to call ->set_config
|
|
|
|
|
* @set: modeset config to set
|
|
|
|
|
*
|
|
|
|
|
* This is a little helper to wrap internal calls to the ->set_config driver
|
|
|
|
|
* interface. The only thing it adds is correct refcounting dance.
|
2014-03-10 20:33:02 +00:00
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* Zero on success, errno on failure.
|
2012-12-11 12:47:23 +00:00
|
|
|
*/
|
|
|
|
|
int drm_mode_set_config_internal(struct drm_mode_set *set)
|
|
|
|
|
{
|
|
|
|
|
struct drm_crtc *crtc = set->crtc;
|
2013-06-14 22:13:16 +00:00
|
|
|
struct drm_framebuffer *fb;
|
|
|
|
|
struct drm_crtc *tmp;
|
2012-12-11 00:07:12 +00:00
|
|
|
int ret;
|
|
|
|
|
|
2013-06-14 22:13:16 +00:00
|
|
|
/*
|
|
|
|
|
* NOTE: ->set_config can also disable other crtcs (if we steal all
|
|
|
|
|
* connectors from it), hence we need to refcount the fbs across all
|
|
|
|
|
* crtcs. Atomic modeset will have saner semantics ...
|
|
|
|
|
*/
|
|
|
|
|
list_for_each_entry(tmp, &crtc->dev->mode_config.crtc_list, head)
|
2014-04-01 22:22:40 +00:00
|
|
|
tmp->old_fb = tmp->primary->fb;
|
2013-06-14 22:13:16 +00:00
|
|
|
|
2012-12-11 00:07:12 +00:00
|
|
|
fb = set->fb;
|
2012-12-11 12:47:23 +00:00
|
|
|
|
2012-12-11 00:07:12 +00:00
|
|
|
ret = crtc->funcs->set_config(set);
|
|
|
|
|
if (ret == 0) {
|
2014-04-01 22:22:38 +00:00
|
|
|
crtc->primary->crtc = crtc;
|
2014-04-23 15:34:06 +00:00
|
|
|
crtc->primary->fb = fb;
|
2013-06-14 22:13:16 +00:00
|
|
|
}
|
2013-06-14 22:13:15 +00:00
|
|
|
|
2013-06-14 22:13:16 +00:00
|
|
|
list_for_each_entry(tmp, &crtc->dev->mode_config.crtc_list, head) {
|
2014-04-01 22:22:40 +00:00
|
|
|
if (tmp->primary->fb)
|
|
|
|
|
drm_framebuffer_reference(tmp->primary->fb);
|
2013-06-14 22:13:16 +00:00
|
|
|
if (tmp->old_fb)
|
|
|
|
|
drm_framebuffer_unreference(tmp->old_fb);
|
2012-12-11 00:07:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
2012-12-11 12:47:23 +00:00
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(drm_mode_set_config_internal);
|
|
|
|
|
|
2014-04-01 22:22:34 +00:00
|
|
|
/**
|
|
|
|
|
* drm_crtc_check_viewport - Checks that a framebuffer is big enough for the
|
|
|
|
|
* CRTC viewport
|
|
|
|
|
* @crtc: CRTC that framebuffer will be displayed on
|
|
|
|
|
* @x: x panning
|
|
|
|
|
* @y: y panning
|
|
|
|
|
* @mode: mode that framebuffer will be displayed under
|
|
|
|
|
* @fb: framebuffer to check size of
|
2013-09-25 15:45:30 +00:00
|
|
|
*/
|
2014-04-01 22:22:34 +00:00
|
|
|
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)
|
2013-09-25 15:45:30 +00:00
|
|
|
|
|
|
|
|
{
|
|
|
|
|
int hdisplay, vdisplay;
|
|
|
|
|
|
|
|
|
|
hdisplay = mode->hdisplay;
|
|
|
|
|
vdisplay = mode->vdisplay;
|
|
|
|
|
|
2013-09-25 15:45:31 +00:00
|
|
|
if (drm_mode_is_stereo(mode)) {
|
|
|
|
|
struct drm_display_mode adjusted = *mode;
|
|
|
|
|
|
|
|
|
|
drm_mode_set_crtcinfo(&adjusted, CRTC_STEREO_DOUBLE);
|
|
|
|
|
hdisplay = adjusted.crtc_hdisplay;
|
|
|
|
|
vdisplay = adjusted.crtc_vdisplay;
|
|
|
|
|
}
|
|
|
|
|
|
2013-09-25 15:45:30 +00:00
|
|
|
if (crtc->invert_dimensions)
|
|
|
|
|
swap(hdisplay, vdisplay);
|
|
|
|
|
|
|
|
|
|
if (hdisplay > fb->width ||
|
|
|
|
|
vdisplay > fb->height ||
|
|
|
|
|
x > fb->width - hdisplay ||
|
|
|
|
|
y > fb->height - vdisplay) {
|
|
|
|
|
DRM_DEBUG_KMS("Invalid fb size %ux%u for CRTC viewport %ux%u+%d+%d%s.\n",
|
|
|
|
|
fb->width, fb->height, hdisplay, vdisplay, x, y,
|
|
|
|
|
crtc->invert_dimensions ? " (inverted)" : "");
|
|
|
|
|
return -ENOSPC;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2014-04-01 22:22:34 +00:00
|
|
|
EXPORT_SYMBOL(drm_crtc_check_viewport);
|
2013-09-25 15:45:30 +00:00
|
|
|
|
2008-11-07 22:05:41 +00:00
|
|
|
/**
|
|
|
|
|
* drm_mode_setcrtc - set CRTC configuration
|
2012-12-01 23:09:18 +00:00
|
|
|
* @dev: drm device for the ioctl
|
|
|
|
|
* @data: data pointer for the ioctl
|
|
|
|
|
* @file_priv: drm file for the ioctl call
|
2008-11-07 22:05:41 +00:00
|
|
|
*
|
|
|
|
|
* Build a new CRTC configuration based on user request.
|
|
|
|
|
*
|
|
|
|
|
* Called by the user via ioctl.
|
|
|
|
|
*
|
2014-03-10 20:33:02 +00:00
|
|
|
* Returns:
|
2008-11-07 22:05:41 +00:00
|
|
|
* Zero on success, errno on failure.
|
|
|
|
|
*/
|
|
|
|
|
int drm_mode_setcrtc(struct drm_device *dev, void *data,
|
|
|
|
|
struct drm_file *file_priv)
|
|
|
|
|
{
|
|
|
|
|
struct drm_mode_config *config = &dev->mode_config;
|
|
|
|
|
struct drm_mode_crtc *crtc_req = data;
|
2012-03-13 10:35:38 +00:00
|
|
|
struct drm_crtc *crtc;
|
2008-11-07 22:05:41 +00:00
|
|
|
struct drm_connector **connector_set = NULL, *connector;
|
|
|
|
|
struct drm_framebuffer *fb = NULL;
|
|
|
|
|
struct drm_display_mode *mode = NULL;
|
|
|
|
|
struct drm_mode_set set;
|
|
|
|
|
uint32_t __user *set_connectors_ptr;
|
2012-05-17 11:27:21 +00:00
|
|
|
int ret;
|
2008-11-07 22:05:41 +00:00
|
|
|
int i;
|
|
|
|
|
|
2011-02-08 03:55:21 +00:00
|
|
|
if (!drm_core_check_feature(dev, DRIVER_MODESET))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2012-03-13 10:35:41 +00:00
|
|
|
/* For some reason crtc x/y offsets are signed internally. */
|
|
|
|
|
if (crtc_req->x > INT_MAX || crtc_req->y > INT_MAX)
|
|
|
|
|
return -ERANGE;
|
|
|
|
|
|
2012-12-01 23:28:11 +00:00
|
|
|
drm_modeset_lock_all(dev);
|
2013-10-05 20:36:52 +00:00
|
|
|
crtc = drm_crtc_find(dev, crtc_req->crtc_id);
|
|
|
|
|
if (!crtc) {
|
2009-07-20 05:48:07 +00:00
|
|
|
DRM_DEBUG_KMS("Unknown CRTC ID %d\n", crtc_req->crtc_id);
|
2013-10-17 10:35:00 +00:00
|
|
|
ret = -ENOENT;
|
2008-11-07 22:05:41 +00:00
|
|
|
goto out;
|
|
|
|
|
}
|
2010-07-15 19:43:25 +00:00
|
|
|
DRM_DEBUG_KMS("[CRTC:%d]\n", crtc->base.id);
|
2008-11-07 22:05:41 +00:00
|
|
|
|
|
|
|
|
if (crtc_req->mode_valid) {
|
|
|
|
|
/* If we have a mode we need a framebuffer. */
|
|
|
|
|
/* If we pass -1, set the mode with the currently bound fb */
|
|
|
|
|
if (crtc_req->fb_id == -1) {
|
2014-04-01 22:22:40 +00:00
|
|
|
if (!crtc->primary->fb) {
|
2012-03-13 10:35:38 +00:00
|
|
|
DRM_DEBUG_KMS("CRTC doesn't have current FB\n");
|
|
|
|
|
ret = -EINVAL;
|
|
|
|
|
goto out;
|
2008-11-07 22:05:41 +00:00
|
|
|
}
|
2014-04-01 22:22:40 +00:00
|
|
|
fb = crtc->primary->fb;
|
2012-12-11 00:07:12 +00:00
|
|
|
/* Make refcounting symmetric with the lookup path. */
|
|
|
|
|
drm_framebuffer_reference(fb);
|
2008-11-07 22:05:41 +00:00
|
|
|
} else {
|
2012-12-02 20:53:40 +00:00
|
|
|
fb = drm_framebuffer_lookup(dev, crtc_req->fb_id);
|
|
|
|
|
if (!fb) {
|
2009-07-20 05:48:07 +00:00
|
|
|
DRM_DEBUG_KMS("Unknown FB ID%d\n",
|
|
|
|
|
crtc_req->fb_id);
|
2013-10-17 10:35:01 +00:00
|
|
|
ret = -ENOENT;
|
2008-11-07 22:05:41 +00:00
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
mode = drm_mode_create(dev);
|
2012-03-13 10:35:43 +00:00
|
|
|
if (!mode) {
|
|
|
|
|
ret = -ENOMEM;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
2012-03-13 10:35:44 +00:00
|
|
|
ret = drm_crtc_convert_umode(mode, &crtc_req->mode);
|
|
|
|
|
if (ret) {
|
|
|
|
|
DRM_DEBUG_KMS("Invalid mode\n");
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
2008-11-07 22:05:41 +00:00
|
|
|
drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V);
|
2012-03-13 10:35:45 +00:00
|
|
|
|
2013-09-25 15:45:30 +00:00
|
|
|
ret = drm_crtc_check_viewport(crtc, crtc_req->x, crtc_req->y,
|
|
|
|
|
mode, fb);
|
|
|
|
|
if (ret)
|
2012-03-13 10:35:45 +00:00
|
|
|
goto out;
|
2013-09-25 15:45:30 +00:00
|
|
|
|
2008-11-07 22:05:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (crtc_req->count_connectors == 0 && mode) {
|
2009-07-20 05:48:07 +00:00
|
|
|
DRM_DEBUG_KMS("Count connectors is 0 but mode set\n");
|
2008-11-07 22:05:41 +00:00
|
|
|
ret = -EINVAL;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
2009-08-03 12:43:58 +00:00
|
|
|
if (crtc_req->count_connectors > 0 && (!mode || !fb)) {
|
2009-07-20 05:48:07 +00:00
|
|
|
DRM_DEBUG_KMS("Count connectors is %d but no mode or fb set\n",
|
2008-11-07 22:05:41 +00:00
|
|
|
crtc_req->count_connectors);
|
|
|
|
|
ret = -EINVAL;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (crtc_req->count_connectors > 0) {
|
|
|
|
|
u32 out_id;
|
|
|
|
|
|
|
|
|
|
/* Avoid unbounded kernel memory allocation */
|
|
|
|
|
if (crtc_req->count_connectors > config->num_connector) {
|
|
|
|
|
ret = -EINVAL;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
connector_set = kmalloc(crtc_req->count_connectors *
|
|
|
|
|
sizeof(struct drm_connector *),
|
|
|
|
|
GFP_KERNEL);
|
|
|
|
|
if (!connector_set) {
|
|
|
|
|
ret = -ENOMEM;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < crtc_req->count_connectors; i++) {
|
2011-12-19 22:06:42 +00:00
|
|
|
set_connectors_ptr = (uint32_t __user *)(unsigned long)crtc_req->set_connectors_ptr;
|
2008-11-07 22:05:41 +00:00
|
|
|
if (get_user(out_id, &set_connectors_ptr[i])) {
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
2013-10-05 20:36:52 +00:00
|
|
|
connector = drm_connector_find(dev, out_id);
|
|
|
|
|
if (!connector) {
|
2009-07-20 05:48:07 +00:00
|
|
|
DRM_DEBUG_KMS("Connector id %d unknown\n",
|
|
|
|
|
out_id);
|
2013-10-17 10:35:00 +00:00
|
|
|
ret = -ENOENT;
|
2008-11-07 22:05:41 +00:00
|
|
|
goto out;
|
|
|
|
|
}
|
2010-07-15 19:43:25 +00:00
|
|
|
DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n",
|
|
|
|
|
connector->base.id,
|
2014-06-03 11:56:20 +00:00
|
|
|
connector->name);
|
2008-11-07 22:05:41 +00:00
|
|
|
|
|
|
|
|
connector_set[i] = connector;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
set.crtc = crtc;
|
|
|
|
|
set.x = crtc_req->x;
|
|
|
|
|
set.y = crtc_req->y;
|
|
|
|
|
set.mode = mode;
|
|
|
|
|
set.connectors = connector_set;
|
|
|
|
|
set.num_connectors = crtc_req->count_connectors;
|
2009-08-17 03:11:23 +00:00
|
|
|
set.fb = fb;
|
2012-12-11 12:47:23 +00:00
|
|
|
ret = drm_mode_set_config_internal(&set);
|
2008-11-07 22:05:41 +00:00
|
|
|
|
|
|
|
|
out:
|
2012-12-11 00:07:12 +00:00
|
|
|
if (fb)
|
|
|
|
|
drm_framebuffer_unreference(fb);
|
|
|
|
|
|
2008-11-07 22:05:41 +00:00
|
|
|
kfree(connector_set);
|
2012-03-13 10:35:43 +00:00
|
|
|
drm_mode_destroy(dev, mode);
|
2012-12-01 23:28:11 +00:00
|
|
|
drm_modeset_unlock_all(dev);
|
2008-11-07 22:05:41 +00:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2013-06-20 01:48:52 +00:00
|
|
|
static int drm_mode_cursor_common(struct drm_device *dev,
|
|
|
|
|
struct drm_mode_cursor2 *req,
|
|
|
|
|
struct drm_file *file_priv)
|
2008-11-07 22:05:41 +00:00
|
|
|
{
|
|
|
|
|
struct drm_crtc *crtc;
|
|
|
|
|
int ret = 0;
|
|
|
|
|
|
2011-02-08 03:55:21 +00:00
|
|
|
if (!drm_core_check_feature(dev, DRIVER_MODESET))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2012-08-16 08:29:03 +00:00
|
|
|
if (!req->flags || (~DRM_MODE_CURSOR_FLAGS & req->flags))
|
2008-11-07 22:05:41 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
2013-10-05 20:36:52 +00:00
|
|
|
crtc = drm_crtc_find(dev, req->crtc_id);
|
|
|
|
|
if (!crtc) {
|
2009-07-20 05:48:07 +00:00
|
|
|
DRM_DEBUG_KMS("Unknown CRTC ID %d\n", req->crtc_id);
|
2013-10-17 10:35:00 +00:00
|
|
|
return -ENOENT;
|
2008-11-07 22:05:41 +00:00
|
|
|
}
|
|
|
|
|
|
2013-11-19 17:10:12 +00:00
|
|
|
drm_modeset_lock(&crtc->mutex, NULL);
|
2008-11-07 22:05:41 +00:00
|
|
|
if (req->flags & DRM_MODE_CURSOR_BO) {
|
2013-06-20 01:48:52 +00:00
|
|
|
if (!crtc->funcs->cursor_set && !crtc->funcs->cursor_set2) {
|
2008-11-07 22:05:41 +00:00
|
|
|
ret = -ENXIO;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
/* Turns off the cursor if handle is 0 */
|
2013-06-20 01:48:52 +00:00
|
|
|
if (crtc->funcs->cursor_set2)
|
|
|
|
|
ret = crtc->funcs->cursor_set2(crtc, file_priv, req->handle,
|
|
|
|
|
req->width, req->height, req->hot_x, req->hot_y);
|
|
|
|
|
else
|
|
|
|
|
ret = crtc->funcs->cursor_set(crtc, file_priv, req->handle,
|
|
|
|
|
req->width, req->height);
|
2008-11-07 22:05:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (req->flags & DRM_MODE_CURSOR_MOVE) {
|
|
|
|
|
if (crtc->funcs->cursor_move) {
|
|
|
|
|
ret = crtc->funcs->cursor_move(crtc, req->x, req->y);
|
|
|
|
|
} else {
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
out:
|
2013-11-19 17:10:12 +00:00
|
|
|
drm_modeset_unlock(&crtc->mutex);
|
2012-12-02 14:24:10 +00:00
|
|
|
|
2008-11-07 22:05:41 +00:00
|
|
|
return ret;
|
2013-06-20 01:48:52 +00:00
|
|
|
|
|
|
|
|
}
|
2014-03-10 20:33:02 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* drm_mode_cursor_ioctl - set CRTC's cursor configuration
|
|
|
|
|
* @dev: drm device for the ioctl
|
|
|
|
|
* @data: data pointer for the ioctl
|
|
|
|
|
* @file_priv: drm file for the ioctl call
|
|
|
|
|
*
|
|
|
|
|
* Set the cursor configuration based on user request.
|
|
|
|
|
*
|
|
|
|
|
* Called by the user via ioctl.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* Zero on success, errno on failure.
|
|
|
|
|
*/
|
2013-06-20 01:48:52 +00:00
|
|
|
int drm_mode_cursor_ioctl(struct drm_device *dev,
|
2014-03-10 20:33:02 +00:00
|
|
|
void *data, struct drm_file *file_priv)
|
2013-06-20 01:48:52 +00:00
|
|
|
{
|
|
|
|
|
struct drm_mode_cursor *req = data;
|
|
|
|
|
struct drm_mode_cursor2 new_req;
|
|
|
|
|
|
|
|
|
|
memcpy(&new_req, req, sizeof(struct drm_mode_cursor));
|
|
|
|
|
new_req.hot_x = new_req.hot_y = 0;
|
|
|
|
|
|
|
|
|
|
return drm_mode_cursor_common(dev, &new_req, file_priv);
|
|
|
|
|
}
|
|
|
|
|
|
2014-03-10 20:33:02 +00:00
|
|
|
/**
|
|
|
|
|
* drm_mode_cursor2_ioctl - set CRTC's cursor configuration
|
|
|
|
|
* @dev: drm device for the ioctl
|
|
|
|
|
* @data: data pointer for the ioctl
|
|
|
|
|
* @file_priv: drm file for the ioctl call
|
|
|
|
|
*
|
|
|
|
|
* Set the cursor configuration based on user request. This implements the 2nd
|
|
|
|
|
* version of the cursor ioctl, which allows userspace to additionally specify
|
|
|
|
|
* the hotspot of the pointer.
|
|
|
|
|
*
|
|
|
|
|
* Called by the user via ioctl.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* Zero on success, errno on failure.
|
|
|
|
|
*/
|
2013-06-20 01:48:52 +00:00
|
|
|
int drm_mode_cursor2_ioctl(struct drm_device *dev,
|
|
|
|
|
void *data, struct drm_file *file_priv)
|
|
|
|
|
{
|
|
|
|
|
struct drm_mode_cursor2 *req = data;
|
|
|
|
|
return drm_mode_cursor_common(dev, req, file_priv);
|
2008-11-07 22:05:41 +00:00
|
|
|
}
|
|
|
|
|
|
2014-03-10 20:33:02 +00:00
|
|
|
/**
|
|
|
|
|
* drm_mode_legacy_fb_format - compute drm fourcc code from legacy description
|
|
|
|
|
* @bpp: bits per pixels
|
|
|
|
|
* @depth: bit depth per pixel
|
|
|
|
|
*
|
|
|
|
|
* Computes a drm fourcc pixel format code for the given @bpp/@depth values.
|
|
|
|
|
* Useful in fbdev emulation code, since that deals in those values.
|
|
|
|
|
*/
|
2011-11-14 22:51:28 +00:00
|
|
|
uint32_t drm_mode_legacy_fb_format(uint32_t bpp, uint32_t depth)
|
|
|
|
|
{
|
|
|
|
|
uint32_t fmt;
|
|
|
|
|
|
|
|
|
|
switch (bpp) {
|
|
|
|
|
case 8:
|
2013-01-31 17:43:38 +00:00
|
|
|
fmt = DRM_FORMAT_C8;
|
2011-11-14 22:51:28 +00:00
|
|
|
break;
|
|
|
|
|
case 16:
|
|
|
|
|
if (depth == 15)
|
2011-11-17 16:05:13 +00:00
|
|
|
fmt = DRM_FORMAT_XRGB1555;
|
2011-11-14 22:51:28 +00:00
|
|
|
else
|
2011-11-17 16:05:13 +00:00
|
|
|
fmt = DRM_FORMAT_RGB565;
|
2011-11-14 22:51:28 +00:00
|
|
|
break;
|
|
|
|
|
case 24:
|
2011-11-17 16:05:13 +00:00
|
|
|
fmt = DRM_FORMAT_RGB888;
|
2011-11-14 22:51:28 +00:00
|
|
|
break;
|
|
|
|
|
case 32:
|
|
|
|
|
if (depth == 24)
|
2011-11-17 16:05:13 +00:00
|
|
|
fmt = DRM_FORMAT_XRGB8888;
|
2011-11-14 22:51:28 +00:00
|
|
|
else if (depth == 30)
|
2011-11-17 16:05:13 +00:00
|
|
|
fmt = DRM_FORMAT_XRGB2101010;
|
2011-11-14 22:51:28 +00:00
|
|
|
else
|
2011-11-17 16:05:13 +00:00
|
|
|
fmt = DRM_FORMAT_ARGB8888;
|
2011-11-14 22:51:28 +00:00
|
|
|
break;
|
|
|
|
|
default:
|
2011-11-17 16:05:13 +00:00
|
|
|
DRM_ERROR("bad bpp, assuming x8r8g8b8 pixel format\n");
|
|
|
|
|
fmt = DRM_FORMAT_XRGB8888;
|
2011-11-14 22:51:28 +00:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return fmt;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(drm_mode_legacy_fb_format);
|
|
|
|
|
|
2008-11-07 22:05:41 +00:00
|
|
|
/**
|
|
|
|
|
* drm_mode_addfb - add an FB to the graphics configuration
|
2012-12-01 23:09:18 +00:00
|
|
|
* @dev: drm device for the ioctl
|
|
|
|
|
* @data: data pointer for the ioctl
|
|
|
|
|
* @file_priv: drm file for the ioctl call
|
2008-11-07 22:05:41 +00:00
|
|
|
*
|
2014-03-10 20:33:02 +00:00
|
|
|
* Add a new FB to the specified CRTC, given a user request. This is the
|
|
|
|
|
* original addfb ioclt which only supported RGB formats.
|
2008-11-07 22:05:41 +00:00
|
|
|
*
|
|
|
|
|
* Called by the user via ioctl.
|
|
|
|
|
*
|
2014-03-10 20:33:02 +00:00
|
|
|
* Returns:
|
2008-11-07 22:05:41 +00:00
|
|
|
* Zero on success, errno on failure.
|
|
|
|
|
*/
|
|
|
|
|
int drm_mode_addfb(struct drm_device *dev,
|
|
|
|
|
void *data, struct drm_file *file_priv)
|
|
|
|
|
{
|
2011-11-14 22:51:28 +00:00
|
|
|
struct drm_mode_fb_cmd *or = data;
|
|
|
|
|
struct drm_mode_fb_cmd2 r = {};
|
|
|
|
|
struct drm_mode_config *config = &dev->mode_config;
|
|
|
|
|
struct drm_framebuffer *fb;
|
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
|
|
/* Use new struct with format internally */
|
|
|
|
|
r.fb_id = or->fb_id;
|
|
|
|
|
r.width = or->width;
|
|
|
|
|
r.height = or->height;
|
|
|
|
|
r.pitches[0] = or->pitch;
|
|
|
|
|
r.pixel_format = drm_mode_legacy_fb_format(or->bpp, or->depth);
|
|
|
|
|
r.handles[0] = or->handle;
|
|
|
|
|
|
|
|
|
|
if (!drm_core_check_feature(dev, DRIVER_MODESET))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2011-11-07 20:03:23 +00:00
|
|
|
if ((config->min_width > r.width) || (r.width > config->max_width))
|
2011-11-14 22:51:28 +00:00
|
|
|
return -EINVAL;
|
2011-11-07 20:03:23 +00:00
|
|
|
|
|
|
|
|
if ((config->min_height > r.height) || (r.height > config->max_height))
|
2011-11-14 22:51:28 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
fb = dev->mode_config.funcs->fb_create(dev, file_priv, &r);
|
|
|
|
|
if (IS_ERR(fb)) {
|
2012-05-01 16:38:35 +00:00
|
|
|
DRM_DEBUG_KMS("could not create framebuffer\n");
|
drm: revamp locking around fb creation/destruction
Well, at least step 1. The goal here is that framebuffer objects can
survive outside of the mode_config lock, with just a reference held
as protection. The first step to get there is to introduce a special
fb_lock which protects fb lookup, creation and destruction, to make
them appear atomic.
This new fb_lock can nest within the mode_config lock. But the idea is
(once the reference counting part is completed) that we only quickly
take that fb_lock to lookup a framebuffer and grab a reference,
without any other locks involved.
vmwgfx is the only driver which does framebuffer lookups itself, also
wrap those calls to drm_mode_object_find with the new lock.
Also protect the fb_list walking in i915 and omapdrm with the new lock.
As a slight complication there's also the list of user-created fbs
attached to the file private. The problem now is that at fclose() time
we need to walk that list, eventually do a modeset call to remove the
fb from active usage (and are required to be able to take the
mode_config lock), but in the end we need to grab the new fb_lock to
remove the fb from the list. The easiest solution is to add another
mutex to protect this per-file list.
Currently that new fbs_lock nests within the modeset locks and so
appears redudant. But later patches will switch around this sequence
so that taking the modeset locks in the fb destruction path is
optional in the fastpath. Ultimately the goal is that addfb and rmfb
do not require the mode_config lock, since otherwise they have the
potential to introduce stalls in the pageflip sequence of a compositor
(if the compositor e.g. switches to a fullscreen client or if it
enables a plane). But that requires a few more steps and hoops to jump
through.
Note that framebuffer creation/destruction is now double-protected -
once by the fb_lock and in parts by the idr_lock. The later would be
unnecessariy if framebuffers would have their own idr allocator. But
that's material for another patch (series).
v2: Properly initialize the fb->filp_head list in _init, otherwise the
newly added WARN to check whether the fb isn't on a fpriv list any
more will fail for driver-private objects.
v3: Fixup two error-case unlock bugs spotted by Richard Wilbur.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-10 20:19:18 +00:00
|
|
|
return PTR_ERR(fb);
|
2011-11-14 22:51:28 +00:00
|
|
|
}
|
|
|
|
|
|
drm: revamp locking around fb creation/destruction
Well, at least step 1. The goal here is that framebuffer objects can
survive outside of the mode_config lock, with just a reference held
as protection. The first step to get there is to introduce a special
fb_lock which protects fb lookup, creation and destruction, to make
them appear atomic.
This new fb_lock can nest within the mode_config lock. But the idea is
(once the reference counting part is completed) that we only quickly
take that fb_lock to lookup a framebuffer and grab a reference,
without any other locks involved.
vmwgfx is the only driver which does framebuffer lookups itself, also
wrap those calls to drm_mode_object_find with the new lock.
Also protect the fb_list walking in i915 and omapdrm with the new lock.
As a slight complication there's also the list of user-created fbs
attached to the file private. The problem now is that at fclose() time
we need to walk that list, eventually do a modeset call to remove the
fb from active usage (and are required to be able to take the
mode_config lock), but in the end we need to grab the new fb_lock to
remove the fb from the list. The easiest solution is to add another
mutex to protect this per-file list.
Currently that new fbs_lock nests within the modeset locks and so
appears redudant. But later patches will switch around this sequence
so that taking the modeset locks in the fb destruction path is
optional in the fastpath. Ultimately the goal is that addfb and rmfb
do not require the mode_config lock, since otherwise they have the
potential to introduce stalls in the pageflip sequence of a compositor
(if the compositor e.g. switches to a fullscreen client or if it
enables a plane). But that requires a few more steps and hoops to jump
through.
Note that framebuffer creation/destruction is now double-protected -
once by the fb_lock and in parts by the idr_lock. The later would be
unnecessariy if framebuffers would have their own idr allocator. But
that's material for another patch (series).
v2: Properly initialize the fb->filp_head list in _init, otherwise the
newly added WARN to check whether the fb isn't on a fpriv list any
more will fail for driver-private objects.
v3: Fixup two error-case unlock bugs spotted by Richard Wilbur.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-10 20:19:18 +00:00
|
|
|
mutex_lock(&file_priv->fbs_lock);
|
2011-11-14 22:51:28 +00:00
|
|
|
or->fb_id = fb->base.id;
|
|
|
|
|
list_add(&fb->filp_head, &file_priv->fbs);
|
|
|
|
|
DRM_DEBUG_KMS("[FB:%d]\n", fb->base.id);
|
drm: revamp locking around fb creation/destruction
Well, at least step 1. The goal here is that framebuffer objects can
survive outside of the mode_config lock, with just a reference held
as protection. The first step to get there is to introduce a special
fb_lock which protects fb lookup, creation and destruction, to make
them appear atomic.
This new fb_lock can nest within the mode_config lock. But the idea is
(once the reference counting part is completed) that we only quickly
take that fb_lock to lookup a framebuffer and grab a reference,
without any other locks involved.
vmwgfx is the only driver which does framebuffer lookups itself, also
wrap those calls to drm_mode_object_find with the new lock.
Also protect the fb_list walking in i915 and omapdrm with the new lock.
As a slight complication there's also the list of user-created fbs
attached to the file private. The problem now is that at fclose() time
we need to walk that list, eventually do a modeset call to remove the
fb from active usage (and are required to be able to take the
mode_config lock), but in the end we need to grab the new fb_lock to
remove the fb from the list. The easiest solution is to add another
mutex to protect this per-file list.
Currently that new fbs_lock nests within the modeset locks and so
appears redudant. But later patches will switch around this sequence
so that taking the modeset locks in the fb destruction path is
optional in the fastpath. Ultimately the goal is that addfb and rmfb
do not require the mode_config lock, since otherwise they have the
potential to introduce stalls in the pageflip sequence of a compositor
(if the compositor e.g. switches to a fullscreen client or if it
enables a plane). But that requires a few more steps and hoops to jump
through.
Note that framebuffer creation/destruction is now double-protected -
once by the fb_lock and in parts by the idr_lock. The later would be
unnecessariy if framebuffers would have their own idr allocator. But
that's material for another patch (series).
v2: Properly initialize the fb->filp_head list in _init, otherwise the
newly added WARN to check whether the fb isn't on a fpriv list any
more will fail for driver-private objects.
v3: Fixup two error-case unlock bugs spotted by Richard Wilbur.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-10 20:19:18 +00:00
|
|
|
mutex_unlock(&file_priv->fbs_lock);
|
|
|
|
|
|
2011-11-14 22:51:28 +00:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2012-05-24 17:54:00 +00:00
|
|
|
static int format_check(const struct drm_mode_fb_cmd2 *r)
|
2011-12-19 22:06:48 +00:00
|
|
|
{
|
|
|
|
|
uint32_t format = r->pixel_format & ~DRM_FORMAT_BIG_ENDIAN;
|
|
|
|
|
|
|
|
|
|
switch (format) {
|
|
|
|
|
case DRM_FORMAT_C8:
|
|
|
|
|
case DRM_FORMAT_RGB332:
|
|
|
|
|
case DRM_FORMAT_BGR233:
|
|
|
|
|
case DRM_FORMAT_XRGB4444:
|
|
|
|
|
case DRM_FORMAT_XBGR4444:
|
|
|
|
|
case DRM_FORMAT_RGBX4444:
|
|
|
|
|
case DRM_FORMAT_BGRX4444:
|
|
|
|
|
case DRM_FORMAT_ARGB4444:
|
|
|
|
|
case DRM_FORMAT_ABGR4444:
|
|
|
|
|
case DRM_FORMAT_RGBA4444:
|
|
|
|
|
case DRM_FORMAT_BGRA4444:
|
|
|
|
|
case DRM_FORMAT_XRGB1555:
|
|
|
|
|
case DRM_FORMAT_XBGR1555:
|
|
|
|
|
case DRM_FORMAT_RGBX5551:
|
|
|
|
|
case DRM_FORMAT_BGRX5551:
|
|
|
|
|
case DRM_FORMAT_ARGB1555:
|
|
|
|
|
case DRM_FORMAT_ABGR1555:
|
|
|
|
|
case DRM_FORMAT_RGBA5551:
|
|
|
|
|
case DRM_FORMAT_BGRA5551:
|
|
|
|
|
case DRM_FORMAT_RGB565:
|
|
|
|
|
case DRM_FORMAT_BGR565:
|
|
|
|
|
case DRM_FORMAT_RGB888:
|
|
|
|
|
case DRM_FORMAT_BGR888:
|
|
|
|
|
case DRM_FORMAT_XRGB8888:
|
|
|
|
|
case DRM_FORMAT_XBGR8888:
|
|
|
|
|
case DRM_FORMAT_RGBX8888:
|
|
|
|
|
case DRM_FORMAT_BGRX8888:
|
|
|
|
|
case DRM_FORMAT_ARGB8888:
|
|
|
|
|
case DRM_FORMAT_ABGR8888:
|
|
|
|
|
case DRM_FORMAT_RGBA8888:
|
|
|
|
|
case DRM_FORMAT_BGRA8888:
|
|
|
|
|
case DRM_FORMAT_XRGB2101010:
|
|
|
|
|
case DRM_FORMAT_XBGR2101010:
|
|
|
|
|
case DRM_FORMAT_RGBX1010102:
|
|
|
|
|
case DRM_FORMAT_BGRX1010102:
|
|
|
|
|
case DRM_FORMAT_ARGB2101010:
|
|
|
|
|
case DRM_FORMAT_ABGR2101010:
|
|
|
|
|
case DRM_FORMAT_RGBA1010102:
|
|
|
|
|
case DRM_FORMAT_BGRA1010102:
|
|
|
|
|
case DRM_FORMAT_YUYV:
|
|
|
|
|
case DRM_FORMAT_YVYU:
|
|
|
|
|
case DRM_FORMAT_UYVY:
|
|
|
|
|
case DRM_FORMAT_VYUY:
|
|
|
|
|
case DRM_FORMAT_AYUV:
|
|
|
|
|
case DRM_FORMAT_NV12:
|
|
|
|
|
case DRM_FORMAT_NV21:
|
|
|
|
|
case DRM_FORMAT_NV16:
|
|
|
|
|
case DRM_FORMAT_NV61:
|
2012-05-18 21:47:40 +00:00
|
|
|
case DRM_FORMAT_NV24:
|
|
|
|
|
case DRM_FORMAT_NV42:
|
2011-12-19 22:06:48 +00:00
|
|
|
case DRM_FORMAT_YUV410:
|
|
|
|
|
case DRM_FORMAT_YVU410:
|
|
|
|
|
case DRM_FORMAT_YUV411:
|
|
|
|
|
case DRM_FORMAT_YVU411:
|
|
|
|
|
case DRM_FORMAT_YUV420:
|
|
|
|
|
case DRM_FORMAT_YVU420:
|
|
|
|
|
case DRM_FORMAT_YUV422:
|
|
|
|
|
case DRM_FORMAT_YVU422:
|
|
|
|
|
case DRM_FORMAT_YUV444:
|
|
|
|
|
case DRM_FORMAT_YVU444:
|
|
|
|
|
return 0;
|
|
|
|
|
default:
|
2013-10-15 18:06:51 +00:00
|
|
|
DRM_DEBUG_KMS("invalid pixel format %s\n",
|
|
|
|
|
drm_get_format_name(r->pixel_format));
|
2011-12-19 22:06:48 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2012-05-24 17:54:00 +00:00
|
|
|
static int framebuffer_check(const struct drm_mode_fb_cmd2 *r)
|
2012-04-05 18:35:18 +00:00
|
|
|
{
|
|
|
|
|
int ret, hsub, vsub, num_planes, i;
|
|
|
|
|
|
|
|
|
|
ret = format_check(r);
|
|
|
|
|
if (ret) {
|
2013-06-10 08:15:10 +00:00
|
|
|
DRM_DEBUG_KMS("bad framebuffer format %s\n",
|
|
|
|
|
drm_get_format_name(r->pixel_format));
|
2012-04-05 18:35:18 +00:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
hsub = drm_format_horz_chroma_subsampling(r->pixel_format);
|
|
|
|
|
vsub = drm_format_vert_chroma_subsampling(r->pixel_format);
|
|
|
|
|
num_planes = drm_format_num_planes(r->pixel_format);
|
|
|
|
|
|
|
|
|
|
if (r->width == 0 || r->width % hsub) {
|
2012-05-01 16:38:35 +00:00
|
|
|
DRM_DEBUG_KMS("bad framebuffer width %u\n", r->height);
|
2012-04-05 18:35:18 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (r->height == 0 || r->height % vsub) {
|
2012-05-01 16:38:35 +00:00
|
|
|
DRM_DEBUG_KMS("bad framebuffer height %u\n", r->height);
|
2012-04-05 18:35:18 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < num_planes; i++) {
|
|
|
|
|
unsigned int width = r->width / (i != 0 ? hsub : 1);
|
2012-10-25 18:05:04 +00:00
|
|
|
unsigned int height = r->height / (i != 0 ? vsub : 1);
|
|
|
|
|
unsigned int cpp = drm_format_plane_cpp(r->pixel_format, i);
|
2012-04-05 18:35:18 +00:00
|
|
|
|
|
|
|
|
if (!r->handles[i]) {
|
2012-05-01 16:38:35 +00:00
|
|
|
DRM_DEBUG_KMS("no buffer object handle for plane %d\n", i);
|
2012-04-05 18:35:18 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
|
|
|
|
|
2012-10-25 18:05:04 +00:00
|
|
|
if ((uint64_t) width * cpp > UINT_MAX)
|
|
|
|
|
return -ERANGE;
|
|
|
|
|
|
|
|
|
|
if ((uint64_t) height * r->pitches[i] + r->offsets[i] > UINT_MAX)
|
|
|
|
|
return -ERANGE;
|
|
|
|
|
|
|
|
|
|
if (r->pitches[i] < width * cpp) {
|
2012-05-01 16:38:35 +00:00
|
|
|
DRM_DEBUG_KMS("bad pitch %u for plane %d\n", r->pitches[i], i);
|
2012-04-05 18:35:18 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2011-11-14 22:51:28 +00:00
|
|
|
/**
|
|
|
|
|
* drm_mode_addfb2 - add an FB to the graphics configuration
|
2012-12-01 23:09:18 +00:00
|
|
|
* @dev: drm device for the ioctl
|
|
|
|
|
* @data: data pointer for the ioctl
|
|
|
|
|
* @file_priv: drm file for the ioctl call
|
2011-11-14 22:51:28 +00:00
|
|
|
*
|
2014-03-10 20:33:02 +00:00
|
|
|
* Add a new FB to the specified CRTC, given a user request with format. This is
|
|
|
|
|
* the 2nd version of the addfb ioctl, which supports multi-planar framebuffers
|
|
|
|
|
* and uses fourcc codes as pixel format specifiers.
|
2011-11-14 22:51:28 +00:00
|
|
|
*
|
|
|
|
|
* Called by the user via ioctl.
|
|
|
|
|
*
|
2014-03-10 20:33:02 +00:00
|
|
|
* Returns:
|
2011-11-14 22:51:28 +00:00
|
|
|
* Zero on success, errno on failure.
|
|
|
|
|
*/
|
|
|
|
|
int drm_mode_addfb2(struct drm_device *dev,
|
|
|
|
|
void *data, struct drm_file *file_priv)
|
|
|
|
|
{
|
|
|
|
|
struct drm_mode_fb_cmd2 *r = data;
|
2008-11-07 22:05:41 +00:00
|
|
|
struct drm_mode_config *config = &dev->mode_config;
|
|
|
|
|
struct drm_framebuffer *fb;
|
2012-05-17 11:27:21 +00:00
|
|
|
int ret;
|
2008-11-07 22:05:41 +00:00
|
|
|
|
2011-02-08 03:55:21 +00:00
|
|
|
if (!drm_core_check_feature(dev, DRIVER_MODESET))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2012-11-08 09:09:42 +00:00
|
|
|
if (r->flags & ~DRM_MODE_FB_INTERLACED) {
|
|
|
|
|
DRM_DEBUG_KMS("bad framebuffer flags 0x%08x\n", r->flags);
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
|
|
|
|
|
2008-11-07 22:05:41 +00:00
|
|
|
if ((config->min_width > r->width) || (r->width > config->max_width)) {
|
2012-05-01 16:38:35 +00:00
|
|
|
DRM_DEBUG_KMS("bad framebuffer width %d, should be >= %d && <= %d\n",
|
2011-11-14 22:51:27 +00:00
|
|
|
r->width, config->min_width, config->max_width);
|
2008-11-07 22:05:41 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
|
|
|
|
if ((config->min_height > r->height) || (r->height > config->max_height)) {
|
2012-05-01 16:38:35 +00:00
|
|
|
DRM_DEBUG_KMS("bad framebuffer height %d, should be >= %d && <= %d\n",
|
2011-11-14 22:51:27 +00:00
|
|
|
r->height, config->min_height, config->max_height);
|
2008-11-07 22:05:41 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
|
|
|
|
|
2012-04-05 18:35:18 +00:00
|
|
|
ret = framebuffer_check(r);
|
|
|
|
|
if (ret)
|
2011-12-19 22:06:48 +00:00
|
|
|
return ret;
|
|
|
|
|
|
2008-11-07 22:05:41 +00:00
|
|
|
fb = dev->mode_config.funcs->fb_create(dev, file_priv, r);
|
2010-08-08 12:36:38 +00:00
|
|
|
if (IS_ERR(fb)) {
|
2012-05-01 16:38:35 +00:00
|
|
|
DRM_DEBUG_KMS("could not create framebuffer\n");
|
drm: revamp locking around fb creation/destruction
Well, at least step 1. The goal here is that framebuffer objects can
survive outside of the mode_config lock, with just a reference held
as protection. The first step to get there is to introduce a special
fb_lock which protects fb lookup, creation and destruction, to make
them appear atomic.
This new fb_lock can nest within the mode_config lock. But the idea is
(once the reference counting part is completed) that we only quickly
take that fb_lock to lookup a framebuffer and grab a reference,
without any other locks involved.
vmwgfx is the only driver which does framebuffer lookups itself, also
wrap those calls to drm_mode_object_find with the new lock.
Also protect the fb_list walking in i915 and omapdrm with the new lock.
As a slight complication there's also the list of user-created fbs
attached to the file private. The problem now is that at fclose() time
we need to walk that list, eventually do a modeset call to remove the
fb from active usage (and are required to be able to take the
mode_config lock), but in the end we need to grab the new fb_lock to
remove the fb from the list. The easiest solution is to add another
mutex to protect this per-file list.
Currently that new fbs_lock nests within the modeset locks and so
appears redudant. But later patches will switch around this sequence
so that taking the modeset locks in the fb destruction path is
optional in the fastpath. Ultimately the goal is that addfb and rmfb
do not require the mode_config lock, since otherwise they have the
potential to introduce stalls in the pageflip sequence of a compositor
(if the compositor e.g. switches to a fullscreen client or if it
enables a plane). But that requires a few more steps and hoops to jump
through.
Note that framebuffer creation/destruction is now double-protected -
once by the fb_lock and in parts by the idr_lock. The later would be
unnecessariy if framebuffers would have their own idr allocator. But
that's material for another patch (series).
v2: Properly initialize the fb->filp_head list in _init, otherwise the
newly added WARN to check whether the fb isn't on a fpriv list any
more will fail for driver-private objects.
v3: Fixup two error-case unlock bugs spotted by Richard Wilbur.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-10 20:19:18 +00:00
|
|
|
return PTR_ERR(fb);
|
2008-11-07 22:05:41 +00:00
|
|
|
}
|
|
|
|
|
|
drm: revamp locking around fb creation/destruction
Well, at least step 1. The goal here is that framebuffer objects can
survive outside of the mode_config lock, with just a reference held
as protection. The first step to get there is to introduce a special
fb_lock which protects fb lookup, creation and destruction, to make
them appear atomic.
This new fb_lock can nest within the mode_config lock. But the idea is
(once the reference counting part is completed) that we only quickly
take that fb_lock to lookup a framebuffer and grab a reference,
without any other locks involved.
vmwgfx is the only driver which does framebuffer lookups itself, also
wrap those calls to drm_mode_object_find with the new lock.
Also protect the fb_list walking in i915 and omapdrm with the new lock.
As a slight complication there's also the list of user-created fbs
attached to the file private. The problem now is that at fclose() time
we need to walk that list, eventually do a modeset call to remove the
fb from active usage (and are required to be able to take the
mode_config lock), but in the end we need to grab the new fb_lock to
remove the fb from the list. The easiest solution is to add another
mutex to protect this per-file list.
Currently that new fbs_lock nests within the modeset locks and so
appears redudant. But later patches will switch around this sequence
so that taking the modeset locks in the fb destruction path is
optional in the fastpath. Ultimately the goal is that addfb and rmfb
do not require the mode_config lock, since otherwise they have the
potential to introduce stalls in the pageflip sequence of a compositor
(if the compositor e.g. switches to a fullscreen client or if it
enables a plane). But that requires a few more steps and hoops to jump
through.
Note that framebuffer creation/destruction is now double-protected -
once by the fb_lock and in parts by the idr_lock. The later would be
unnecessariy if framebuffers would have their own idr allocator. But
that's material for another patch (series).
v2: Properly initialize the fb->filp_head list in _init, otherwise the
newly added WARN to check whether the fb isn't on a fpriv list any
more will fail for driver-private objects.
v3: Fixup two error-case unlock bugs spotted by Richard Wilbur.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-10 20:19:18 +00:00
|
|
|
mutex_lock(&file_priv->fbs_lock);
|
2008-12-19 04:50:50 +00:00
|
|
|
r->fb_id = fb->base.id;
|
2008-11-07 22:05:41 +00:00
|
|
|
list_add(&fb->filp_head, &file_priv->fbs);
|
2010-07-15 19:43:25 +00:00
|
|
|
DRM_DEBUG_KMS("[FB:%d]\n", fb->base.id);
|
drm: revamp locking around fb creation/destruction
Well, at least step 1. The goal here is that framebuffer objects can
survive outside of the mode_config lock, with just a reference held
as protection. The first step to get there is to introduce a special
fb_lock which protects fb lookup, creation and destruction, to make
them appear atomic.
This new fb_lock can nest within the mode_config lock. But the idea is
(once the reference counting part is completed) that we only quickly
take that fb_lock to lookup a framebuffer and grab a reference,
without any other locks involved.
vmwgfx is the only driver which does framebuffer lookups itself, also
wrap those calls to drm_mode_object_find with the new lock.
Also protect the fb_list walking in i915 and omapdrm with the new lock.
As a slight complication there's also the list of user-created fbs
attached to the file private. The problem now is that at fclose() time
we need to walk that list, eventually do a modeset call to remove the
fb from active usage (and are required to be able to take the
mode_config lock), but in the end we need to grab the new fb_lock to
remove the fb from the list. The easiest solution is to add another
mutex to protect this per-file list.
Currently that new fbs_lock nests within the modeset locks and so
appears redudant. But later patches will switch around this sequence
so that taking the modeset locks in the fb destruction path is
optional in the fastpath. Ultimately the goal is that addfb and rmfb
do not require the mode_config lock, since otherwise they have the
potential to introduce stalls in the pageflip sequence of a compositor
(if the compositor e.g. switches to a fullscreen client or if it
enables a plane). But that requires a few more steps and hoops to jump
through.
Note that framebuffer creation/destruction is now double-protected -
once by the fb_lock and in parts by the idr_lock. The later would be
unnecessariy if framebuffers would have their own idr allocator. But
that's material for another patch (series).
v2: Properly initialize the fb->filp_head list in _init, otherwise the
newly added WARN to check whether the fb isn't on a fpriv list any
more will fail for driver-private objects.
v3: Fixup two error-case unlock bugs spotted by Richard Wilbur.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-10 20:19:18 +00:00
|
|
|
mutex_unlock(&file_priv->fbs_lock);
|
2008-11-07 22:05:41 +00:00
|
|
|
|
drm: revamp locking around fb creation/destruction
Well, at least step 1. The goal here is that framebuffer objects can
survive outside of the mode_config lock, with just a reference held
as protection. The first step to get there is to introduce a special
fb_lock which protects fb lookup, creation and destruction, to make
them appear atomic.
This new fb_lock can nest within the mode_config lock. But the idea is
(once the reference counting part is completed) that we only quickly
take that fb_lock to lookup a framebuffer and grab a reference,
without any other locks involved.
vmwgfx is the only driver which does framebuffer lookups itself, also
wrap those calls to drm_mode_object_find with the new lock.
Also protect the fb_list walking in i915 and omapdrm with the new lock.
As a slight complication there's also the list of user-created fbs
attached to the file private. The problem now is that at fclose() time
we need to walk that list, eventually do a modeset call to remove the
fb from active usage (and are required to be able to take the
mode_config lock), but in the end we need to grab the new fb_lock to
remove the fb from the list. The easiest solution is to add another
mutex to protect this per-file list.
Currently that new fbs_lock nests within the modeset locks and so
appears redudant. But later patches will switch around this sequence
so that taking the modeset locks in the fb destruction path is
optional in the fastpath. Ultimately the goal is that addfb and rmfb
do not require the mode_config lock, since otherwise they have the
potential to introduce stalls in the pageflip sequence of a compositor
(if the compositor e.g. switches to a fullscreen client or if it
enables a plane). But that requires a few more steps and hoops to jump
through.
Note that framebuffer creation/destruction is now double-protected -
once by the fb_lock and in parts by the idr_lock. The later would be
unnecessariy if framebuffers would have their own idr allocator. But
that's material for another patch (series).
v2: Properly initialize the fb->filp_head list in _init, otherwise the
newly added WARN to check whether the fb isn't on a fpriv list any
more will fail for driver-private objects.
v3: Fixup two error-case unlock bugs spotted by Richard Wilbur.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-10 20:19:18 +00:00
|
|
|
|
2008-11-07 22:05:41 +00:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* drm_mode_rmfb - remove an FB from the configuration
|
2012-12-01 23:09:18 +00:00
|
|
|
* @dev: drm device for the ioctl
|
|
|
|
|
* @data: data pointer for the ioctl
|
|
|
|
|
* @file_priv: drm file for the ioctl call
|
2008-11-07 22:05:41 +00:00
|
|
|
*
|
|
|
|
|
* Remove the FB specified by the user.
|
|
|
|
|
*
|
|
|
|
|
* Called by the user via ioctl.
|
|
|
|
|
*
|
2014-03-10 20:33:02 +00:00
|
|
|
* Returns:
|
2008-11-07 22:05:41 +00:00
|
|
|
* Zero on success, errno on failure.
|
|
|
|
|
*/
|
|
|
|
|
int drm_mode_rmfb(struct drm_device *dev,
|
|
|
|
|
void *data, struct drm_file *file_priv)
|
|
|
|
|
{
|
|
|
|
|
struct drm_framebuffer *fb = NULL;
|
|
|
|
|
struct drm_framebuffer *fbl = NULL;
|
|
|
|
|
uint32_t *id = data;
|
|
|
|
|
int found = 0;
|
|
|
|
|
|
2011-02-08 03:55:21 +00:00
|
|
|
if (!drm_core_check_feature(dev, DRIVER_MODESET))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
drm: revamp locking around fb creation/destruction
Well, at least step 1. The goal here is that framebuffer objects can
survive outside of the mode_config lock, with just a reference held
as protection. The first step to get there is to introduce a special
fb_lock which protects fb lookup, creation and destruction, to make
them appear atomic.
This new fb_lock can nest within the mode_config lock. But the idea is
(once the reference counting part is completed) that we only quickly
take that fb_lock to lookup a framebuffer and grab a reference,
without any other locks involved.
vmwgfx is the only driver which does framebuffer lookups itself, also
wrap those calls to drm_mode_object_find with the new lock.
Also protect the fb_list walking in i915 and omapdrm with the new lock.
As a slight complication there's also the list of user-created fbs
attached to the file private. The problem now is that at fclose() time
we need to walk that list, eventually do a modeset call to remove the
fb from active usage (and are required to be able to take the
mode_config lock), but in the end we need to grab the new fb_lock to
remove the fb from the list. The easiest solution is to add another
mutex to protect this per-file list.
Currently that new fbs_lock nests within the modeset locks and so
appears redudant. But later patches will switch around this sequence
so that taking the modeset locks in the fb destruction path is
optional in the fastpath. Ultimately the goal is that addfb and rmfb
do not require the mode_config lock, since otherwise they have the
potential to introduce stalls in the pageflip sequence of a compositor
(if the compositor e.g. switches to a fullscreen client or if it
enables a plane). But that requires a few more steps and hoops to jump
through.
Note that framebuffer creation/destruction is now double-protected -
once by the fb_lock and in parts by the idr_lock. The later would be
unnecessariy if framebuffers would have their own idr allocator. But
that's material for another patch (series).
v2: Properly initialize the fb->filp_head list in _init, otherwise the
newly added WARN to check whether the fb isn't on a fpriv list any
more will fail for driver-private objects.
v3: Fixup two error-case unlock bugs spotted by Richard Wilbur.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-10 20:19:18 +00:00
|
|
|
mutex_lock(&file_priv->fbs_lock);
|
drm: reference framebuffers which are on the idr
Since otherwise looking and reference-counting around
drm_framebuffer_lookup will be an unmanageable mess. With this change,
an object can either be found in the idr and will stay around once we
incremented the reference counter. Or it will be gone for good and
can't be looked up using its id any more.
Atomicity is guaranteed by the dev->mode_config.fb_lock. The
newly-introduce fpriv->fbs_lock looks a bit redundant, but the next
patch will shuffle the locking order between these two locks and all
the modeset locks taken in modeset_lock_all, so we'll need it.
Also, since userspace could do really funky stuff and race e.g. a
getresources with an rmfb, we need to make sure that the kernel
doesn't fall over trying to look-up an inexistent fb, or causing
confusion by having two fbs around with the same id. Simply reset the
framebuffer id to 0, which marks it as reaped. Any lookups of that id
will fail, so the object is really gone for good from userspace's pov.
Note that we still need to protect the "remove framebuffer from all
use-cases" and the final unreference with the modeset-lock, since most
framebuffer use-sites don't implement proper reference counting yet.
We can only lift this once _all_ users are converted.
With this change, two references are held on alife, but unused
framebuffers:
- The reference for the idr lookup, created in this patch.
- For user-created framebuffers the fpriv->fbs reference, for
driver-private fbs the driver is supposed to hold it's own last
reference.
Note that the dev->mode_config.fb_list itself does _not_ hold a
reference onto the framebuffers (this list is essentially only used
for debugfs files). Hence if there's anything left there when the
driver has cleaned up all it's modeset resources, this is a ref-leak.
WARN about it.
Now we only need to fix up all other places to properly reference
count framebuffers.
v2: Fix spelling fail in a comment spotted by Rob Clark.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-10 20:16:05 +00:00
|
|
|
mutex_lock(&dev->mode_config.fb_lock);
|
|
|
|
|
fb = __drm_framebuffer_lookup(dev, *id);
|
|
|
|
|
if (!fb)
|
|
|
|
|
goto fail_lookup;
|
|
|
|
|
|
2008-11-07 22:05:41 +00:00
|
|
|
list_for_each_entry(fbl, &file_priv->fbs, filp_head)
|
|
|
|
|
if (fb == fbl)
|
|
|
|
|
found = 1;
|
drm: reference framebuffers which are on the idr
Since otherwise looking and reference-counting around
drm_framebuffer_lookup will be an unmanageable mess. With this change,
an object can either be found in the idr and will stay around once we
incremented the reference counter. Or it will be gone for good and
can't be looked up using its id any more.
Atomicity is guaranteed by the dev->mode_config.fb_lock. The
newly-introduce fpriv->fbs_lock looks a bit redundant, but the next
patch will shuffle the locking order between these two locks and all
the modeset locks taken in modeset_lock_all, so we'll need it.
Also, since userspace could do really funky stuff and race e.g. a
getresources with an rmfb, we need to make sure that the kernel
doesn't fall over trying to look-up an inexistent fb, or causing
confusion by having two fbs around with the same id. Simply reset the
framebuffer id to 0, which marks it as reaped. Any lookups of that id
will fail, so the object is really gone for good from userspace's pov.
Note that we still need to protect the "remove framebuffer from all
use-cases" and the final unreference with the modeset-lock, since most
framebuffer use-sites don't implement proper reference counting yet.
We can only lift this once _all_ users are converted.
With this change, two references are held on alife, but unused
framebuffers:
- The reference for the idr lookup, created in this patch.
- For user-created framebuffers the fpriv->fbs reference, for
driver-private fbs the driver is supposed to hold it's own last
reference.
Note that the dev->mode_config.fb_list itself does _not_ hold a
reference onto the framebuffers (this list is essentially only used
for debugfs files). Hence if there's anything left there when the
driver has cleaned up all it's modeset resources, this is a ref-leak.
WARN about it.
Now we only need to fix up all other places to properly reference
count framebuffers.
v2: Fix spelling fail in a comment spotted by Rob Clark.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-10 20:16:05 +00:00
|
|
|
if (!found)
|
|
|
|
|
goto fail_lookup;
|
|
|
|
|
|
|
|
|
|
/* Mark fb as reaped, we still have a ref from fpriv->fbs. */
|
|
|
|
|
__drm_framebuffer_unregister(dev, fb);
|
2008-11-07 22:05:41 +00:00
|
|
|
|
drm: revamp locking around fb creation/destruction
Well, at least step 1. The goal here is that framebuffer objects can
survive outside of the mode_config lock, with just a reference held
as protection. The first step to get there is to introduce a special
fb_lock which protects fb lookup, creation and destruction, to make
them appear atomic.
This new fb_lock can nest within the mode_config lock. But the idea is
(once the reference counting part is completed) that we only quickly
take that fb_lock to lookup a framebuffer and grab a reference,
without any other locks involved.
vmwgfx is the only driver which does framebuffer lookups itself, also
wrap those calls to drm_mode_object_find with the new lock.
Also protect the fb_list walking in i915 and omapdrm with the new lock.
As a slight complication there's also the list of user-created fbs
attached to the file private. The problem now is that at fclose() time
we need to walk that list, eventually do a modeset call to remove the
fb from active usage (and are required to be able to take the
mode_config lock), but in the end we need to grab the new fb_lock to
remove the fb from the list. The easiest solution is to add another
mutex to protect this per-file list.
Currently that new fbs_lock nests within the modeset locks and so
appears redudant. But later patches will switch around this sequence
so that taking the modeset locks in the fb destruction path is
optional in the fastpath. Ultimately the goal is that addfb and rmfb
do not require the mode_config lock, since otherwise they have the
potential to introduce stalls in the pageflip sequence of a compositor
(if the compositor e.g. switches to a fullscreen client or if it
enables a plane). But that requires a few more steps and hoops to jump
through.
Note that framebuffer creation/destruction is now double-protected -
once by the fb_lock and in parts by the idr_lock. The later would be
unnecessariy if framebuffers would have their own idr allocator. But
that's material for another patch (series).
v2: Properly initialize the fb->filp_head list in _init, otherwise the
newly added WARN to check whether the fb isn't on a fpriv list any
more will fail for driver-private objects.
v3: Fixup two error-case unlock bugs spotted by Richard Wilbur.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-10 20:19:18 +00:00
|
|
|
list_del_init(&fb->filp_head);
|
drm: reference framebuffers which are on the idr
Since otherwise looking and reference-counting around
drm_framebuffer_lookup will be an unmanageable mess. With this change,
an object can either be found in the idr and will stay around once we
incremented the reference counter. Or it will be gone for good and
can't be looked up using its id any more.
Atomicity is guaranteed by the dev->mode_config.fb_lock. The
newly-introduce fpriv->fbs_lock looks a bit redundant, but the next
patch will shuffle the locking order between these two locks and all
the modeset locks taken in modeset_lock_all, so we'll need it.
Also, since userspace could do really funky stuff and race e.g. a
getresources with an rmfb, we need to make sure that the kernel
doesn't fall over trying to look-up an inexistent fb, or causing
confusion by having two fbs around with the same id. Simply reset the
framebuffer id to 0, which marks it as reaped. Any lookups of that id
will fail, so the object is really gone for good from userspace's pov.
Note that we still need to protect the "remove framebuffer from all
use-cases" and the final unreference with the modeset-lock, since most
framebuffer use-sites don't implement proper reference counting yet.
We can only lift this once _all_ users are converted.
With this change, two references are held on alife, but unused
framebuffers:
- The reference for the idr lookup, created in this patch.
- For user-created framebuffers the fpriv->fbs reference, for
driver-private fbs the driver is supposed to hold it's own last
reference.
Note that the dev->mode_config.fb_list itself does _not_ hold a
reference onto the framebuffers (this list is essentially only used
for debugfs files). Hence if there's anything left there when the
driver has cleaned up all it's modeset resources, this is a ref-leak.
WARN about it.
Now we only need to fix up all other places to properly reference
count framebuffers.
v2: Fix spelling fail in a comment spotted by Rob Clark.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-10 20:16:05 +00:00
|
|
|
mutex_unlock(&dev->mode_config.fb_lock);
|
drm: revamp locking around fb creation/destruction
Well, at least step 1. The goal here is that framebuffer objects can
survive outside of the mode_config lock, with just a reference held
as protection. The first step to get there is to introduce a special
fb_lock which protects fb lookup, creation and destruction, to make
them appear atomic.
This new fb_lock can nest within the mode_config lock. But the idea is
(once the reference counting part is completed) that we only quickly
take that fb_lock to lookup a framebuffer and grab a reference,
without any other locks involved.
vmwgfx is the only driver which does framebuffer lookups itself, also
wrap those calls to drm_mode_object_find with the new lock.
Also protect the fb_list walking in i915 and omapdrm with the new lock.
As a slight complication there's also the list of user-created fbs
attached to the file private. The problem now is that at fclose() time
we need to walk that list, eventually do a modeset call to remove the
fb from active usage (and are required to be able to take the
mode_config lock), but in the end we need to grab the new fb_lock to
remove the fb from the list. The easiest solution is to add another
mutex to protect this per-file list.
Currently that new fbs_lock nests within the modeset locks and so
appears redudant. But later patches will switch around this sequence
so that taking the modeset locks in the fb destruction path is
optional in the fastpath. Ultimately the goal is that addfb and rmfb
do not require the mode_config lock, since otherwise they have the
potential to introduce stalls in the pageflip sequence of a compositor
(if the compositor e.g. switches to a fullscreen client or if it
enables a plane). But that requires a few more steps and hoops to jump
through.
Note that framebuffer creation/destruction is now double-protected -
once by the fb_lock and in parts by the idr_lock. The later would be
unnecessariy if framebuffers would have their own idr allocator. But
that's material for another patch (series).
v2: Properly initialize the fb->filp_head list in _init, otherwise the
newly added WARN to check whether the fb isn't on a fpriv list any
more will fail for driver-private objects.
v3: Fixup two error-case unlock bugs spotted by Richard Wilbur.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-10 20:19:18 +00:00
|
|
|
mutex_unlock(&file_priv->fbs_lock);
|
2008-11-07 22:05:41 +00:00
|
|
|
|
drm: revamp locking around fb creation/destruction
Well, at least step 1. The goal here is that framebuffer objects can
survive outside of the mode_config lock, with just a reference held
as protection. The first step to get there is to introduce a special
fb_lock which protects fb lookup, creation and destruction, to make
them appear atomic.
This new fb_lock can nest within the mode_config lock. But the idea is
(once the reference counting part is completed) that we only quickly
take that fb_lock to lookup a framebuffer and grab a reference,
without any other locks involved.
vmwgfx is the only driver which does framebuffer lookups itself, also
wrap those calls to drm_mode_object_find with the new lock.
Also protect the fb_list walking in i915 and omapdrm with the new lock.
As a slight complication there's also the list of user-created fbs
attached to the file private. The problem now is that at fclose() time
we need to walk that list, eventually do a modeset call to remove the
fb from active usage (and are required to be able to take the
mode_config lock), but in the end we need to grab the new fb_lock to
remove the fb from the list. The easiest solution is to add another
mutex to protect this per-file list.
Currently that new fbs_lock nests within the modeset locks and so
appears redudant. But later patches will switch around this sequence
so that taking the modeset locks in the fb destruction path is
optional in the fastpath. Ultimately the goal is that addfb and rmfb
do not require the mode_config lock, since otherwise they have the
potential to introduce stalls in the pageflip sequence of a compositor
(if the compositor e.g. switches to a fullscreen client or if it
enables a plane). But that requires a few more steps and hoops to jump
through.
Note that framebuffer creation/destruction is now double-protected -
once by the fb_lock and in parts by the idr_lock. The later would be
unnecessariy if framebuffers would have their own idr allocator. But
that's material for another patch (series).
v2: Properly initialize the fb->filp_head list in _init, otherwise the
newly added WARN to check whether the fb isn't on a fpriv list any
more will fail for driver-private objects.
v3: Fixup two error-case unlock bugs spotted by Richard Wilbur.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-10 20:19:18 +00:00
|
|
|
drm_framebuffer_remove(fb);
|
|
|
|
|
|
drm: reference framebuffers which are on the idr
Since otherwise looking and reference-counting around
drm_framebuffer_lookup will be an unmanageable mess. With this change,
an object can either be found in the idr and will stay around once we
incremented the reference counter. Or it will be gone for good and
can't be looked up using its id any more.
Atomicity is guaranteed by the dev->mode_config.fb_lock. The
newly-introduce fpriv->fbs_lock looks a bit redundant, but the next
patch will shuffle the locking order between these two locks and all
the modeset locks taken in modeset_lock_all, so we'll need it.
Also, since userspace could do really funky stuff and race e.g. a
getresources with an rmfb, we need to make sure that the kernel
doesn't fall over trying to look-up an inexistent fb, or causing
confusion by having two fbs around with the same id. Simply reset the
framebuffer id to 0, which marks it as reaped. Any lookups of that id
will fail, so the object is really gone for good from userspace's pov.
Note that we still need to protect the "remove framebuffer from all
use-cases" and the final unreference with the modeset-lock, since most
framebuffer use-sites don't implement proper reference counting yet.
We can only lift this once _all_ users are converted.
With this change, two references are held on alife, but unused
framebuffers:
- The reference for the idr lookup, created in this patch.
- For user-created framebuffers the fpriv->fbs reference, for
driver-private fbs the driver is supposed to hold it's own last
reference.
Note that the dev->mode_config.fb_list itself does _not_ hold a
reference onto the framebuffers (this list is essentially only used
for debugfs files). Hence if there's anything left there when the
driver has cleaned up all it's modeset resources, this is a ref-leak.
WARN about it.
Now we only need to fix up all other places to properly reference
count framebuffers.
v2: Fix spelling fail in a comment spotted by Rob Clark.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-10 20:16:05 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
fail_lookup:
|
|
|
|
|
mutex_unlock(&dev->mode_config.fb_lock);
|
|
|
|
|
mutex_unlock(&file_priv->fbs_lock);
|
|
|
|
|
|
2013-10-17 10:35:01 +00:00
|
|
|
return -ENOENT;
|
2008-11-07 22:05:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* drm_mode_getfb - get FB info
|
2012-12-01 23:09:18 +00:00
|
|
|
* @dev: drm device for the ioctl
|
|
|
|
|
* @data: data pointer for the ioctl
|
|
|
|
|
* @file_priv: drm file for the ioctl call
|
2008-11-07 22:05:41 +00:00
|
|
|
*
|
|
|
|
|
* Lookup the FB given its ID and return info about it.
|
|
|
|
|
*
|
|
|
|
|
* Called by the user via ioctl.
|
|
|
|
|
*
|
2014-03-10 20:33:02 +00:00
|
|
|
* Returns:
|
2008-11-07 22:05:41 +00:00
|
|
|
* Zero on success, errno on failure.
|
|
|
|
|
*/
|
|
|
|
|
int drm_mode_getfb(struct drm_device *dev,
|
|
|
|
|
void *data, struct drm_file *file_priv)
|
|
|
|
|
{
|
|
|
|
|
struct drm_mode_fb_cmd *r = data;
|
|
|
|
|
struct drm_framebuffer *fb;
|
2012-12-13 22:06:08 +00:00
|
|
|
int ret;
|
2008-11-07 22:05:41 +00:00
|
|
|
|
2011-02-08 03:55:21 +00:00
|
|
|
if (!drm_core_check_feature(dev, DRIVER_MODESET))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2012-12-02 20:53:40 +00:00
|
|
|
fb = drm_framebuffer_lookup(dev, r->fb_id);
|
2012-12-13 22:06:08 +00:00
|
|
|
if (!fb)
|
2013-10-17 10:35:01 +00:00
|
|
|
return -ENOENT;
|
2008-11-07 22:05:41 +00:00
|
|
|
|
|
|
|
|
r->height = fb->height;
|
|
|
|
|
r->width = fb->width;
|
|
|
|
|
r->depth = fb->depth;
|
|
|
|
|
r->bpp = fb->bits_per_pixel;
|
2011-12-19 22:06:49 +00:00
|
|
|
r->pitch = fb->pitches[0];
|
drm: fix DRM_IOCTL_MODE_GETFB handle-leak
DRM_IOCTL_MODE_GETFB is used to retrieve information about a given
framebuffer ID. It is a read-only helper and was thus declassified for
unprivileged access in:
commit a14b1b42477c5ef089fcda88cbaae50d979eb8f9
Author: Mandeep Singh Baines <mandeep.baines@gmail.com>
Date: Fri Jan 20 12:11:16 2012 -0800
drm: remove master fd restriction on mode setting getters
However, alongside width, height and stride information,
DRM_IOCTL_MODE_GETFB also passes back a handle to the underlying buffer of
the framebuffer. This handle allows users to mmap() it and read or write
into it. Obviously, this should be restricted to DRM-Master.
With the current setup, *any* process with access to /dev/dri/card0 (which
means any process with access to hardware-accelerated rendering) can
access the current screen framebuffer and modify it ad libitum.
For backwards-compatibility reasons we want to keep the
DRM_IOCTL_MODE_GETFB call unprivileged. Besides, it provides quite useful
information regarding screen setup. So we simply test whether the caller
is the current DRM-Master and if not, we return 0 as handle, which is
always invalid. A following DRM_IOCTL_GEM_CLOSE on this handle will fail
with EINVAL, but we accept this. Users shouldn't test for errors during
GEM_CLOSE, anyway. And it is still better as a failing MODE_GETFB call.
v2: add capable(CAP_SYS_ADMIN) check for compatibility with i-g-t
Cc: <stable@vger.kernel.org>
Signed-off-by: David Herrmann <dh.herrmann@gmail.com>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2013-08-26 13:16:49 +00:00
|
|
|
if (fb->funcs->create_handle) {
|
2014-03-13 09:00:42 +00:00
|
|
|
if (file_priv->is_master || capable(CAP_SYS_ADMIN) ||
|
2014-03-13 10:07:44 +00:00
|
|
|
drm_is_control_client(file_priv)) {
|
drm: fix DRM_IOCTL_MODE_GETFB handle-leak
DRM_IOCTL_MODE_GETFB is used to retrieve information about a given
framebuffer ID. It is a read-only helper and was thus declassified for
unprivileged access in:
commit a14b1b42477c5ef089fcda88cbaae50d979eb8f9
Author: Mandeep Singh Baines <mandeep.baines@gmail.com>
Date: Fri Jan 20 12:11:16 2012 -0800
drm: remove master fd restriction on mode setting getters
However, alongside width, height and stride information,
DRM_IOCTL_MODE_GETFB also passes back a handle to the underlying buffer of
the framebuffer. This handle allows users to mmap() it and read or write
into it. Obviously, this should be restricted to DRM-Master.
With the current setup, *any* process with access to /dev/dri/card0 (which
means any process with access to hardware-accelerated rendering) can
access the current screen framebuffer and modify it ad libitum.
For backwards-compatibility reasons we want to keep the
DRM_IOCTL_MODE_GETFB call unprivileged. Besides, it provides quite useful
information regarding screen setup. So we simply test whether the caller
is the current DRM-Master and if not, we return 0 as handle, which is
always invalid. A following DRM_IOCTL_GEM_CLOSE on this handle will fail
with EINVAL, but we accept this. Users shouldn't test for errors during
GEM_CLOSE, anyway. And it is still better as a failing MODE_GETFB call.
v2: add capable(CAP_SYS_ADMIN) check for compatibility with i-g-t
Cc: <stable@vger.kernel.org>
Signed-off-by: David Herrmann <dh.herrmann@gmail.com>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2013-08-26 13:16:49 +00:00
|
|
|
ret = fb->funcs->create_handle(fb, file_priv,
|
|
|
|
|
&r->handle);
|
|
|
|
|
} else {
|
|
|
|
|
/* GET_FB() is an unprivileged ioctl so we must not
|
|
|
|
|
* return a buffer-handle to non-master processes! For
|
|
|
|
|
* backwards-compatibility reasons, we cannot make
|
|
|
|
|
* GET_FB() privileged, so just return an invalid handle
|
|
|
|
|
* for non-masters. */
|
|
|
|
|
r->handle = 0;
|
|
|
|
|
ret = 0;
|
|
|
|
|
}
|
|
|
|
|
} else {
|
2012-12-13 22:07:50 +00:00
|
|
|
ret = -ENODEV;
|
drm: fix DRM_IOCTL_MODE_GETFB handle-leak
DRM_IOCTL_MODE_GETFB is used to retrieve information about a given
framebuffer ID. It is a read-only helper and was thus declassified for
unprivileged access in:
commit a14b1b42477c5ef089fcda88cbaae50d979eb8f9
Author: Mandeep Singh Baines <mandeep.baines@gmail.com>
Date: Fri Jan 20 12:11:16 2012 -0800
drm: remove master fd restriction on mode setting getters
However, alongside width, height and stride information,
DRM_IOCTL_MODE_GETFB also passes back a handle to the underlying buffer of
the framebuffer. This handle allows users to mmap() it and read or write
into it. Obviously, this should be restricted to DRM-Master.
With the current setup, *any* process with access to /dev/dri/card0 (which
means any process with access to hardware-accelerated rendering) can
access the current screen framebuffer and modify it ad libitum.
For backwards-compatibility reasons we want to keep the
DRM_IOCTL_MODE_GETFB call unprivileged. Besides, it provides quite useful
information regarding screen setup. So we simply test whether the caller
is the current DRM-Master and if not, we return 0 as handle, which is
always invalid. A following DRM_IOCTL_GEM_CLOSE on this handle will fail
with EINVAL, but we accept this. Users shouldn't test for errors during
GEM_CLOSE, anyway. And it is still better as a failing MODE_GETFB call.
v2: add capable(CAP_SYS_ADMIN) check for compatibility with i-g-t
Cc: <stable@vger.kernel.org>
Signed-off-by: David Herrmann <dh.herrmann@gmail.com>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2013-08-26 13:16:49 +00:00
|
|
|
}
|
2008-11-07 22:05:41 +00:00
|
|
|
|
2012-12-13 22:06:08 +00:00
|
|
|
drm_framebuffer_unreference(fb);
|
|
|
|
|
|
2008-11-07 22:05:41 +00:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2014-03-10 20:33:02 +00:00
|
|
|
/**
|
|
|
|
|
* drm_mode_dirtyfb_ioctl - flush frontbuffer rendering on an FB
|
|
|
|
|
* @dev: drm device for the ioctl
|
|
|
|
|
* @data: data pointer for the ioctl
|
|
|
|
|
* @file_priv: drm file for the ioctl call
|
|
|
|
|
*
|
|
|
|
|
* Lookup the FB and flush out the damaged area supplied by userspace as a clip
|
|
|
|
|
* rectangle list. Generic userspace which does frontbuffer rendering must call
|
|
|
|
|
* this ioctl to flush out the changes on manual-update display outputs, e.g.
|
|
|
|
|
* usb display-link, mipi manual update panels or edp panel self refresh modes.
|
|
|
|
|
*
|
|
|
|
|
* Modesetting drivers which always update the frontbuffer do not need to
|
|
|
|
|
* implement the corresponding ->dirty framebuffer callback.
|
|
|
|
|
*
|
|
|
|
|
* Called by the user via ioctl.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* Zero on success, errno on failure.
|
|
|
|
|
*/
|
2009-12-03 23:25:47 +00:00
|
|
|
int drm_mode_dirtyfb_ioctl(struct drm_device *dev,
|
|
|
|
|
void *data, struct drm_file *file_priv)
|
|
|
|
|
{
|
|
|
|
|
struct drm_clip_rect __user *clips_ptr;
|
|
|
|
|
struct drm_clip_rect *clips = NULL;
|
|
|
|
|
struct drm_mode_fb_dirty_cmd *r = data;
|
|
|
|
|
struct drm_framebuffer *fb;
|
|
|
|
|
unsigned flags;
|
|
|
|
|
int num_clips;
|
2012-05-17 11:27:21 +00:00
|
|
|
int ret;
|
2009-12-03 23:25:47 +00:00
|
|
|
|
2011-02-08 03:55:21 +00:00
|
|
|
if (!drm_core_check_feature(dev, DRIVER_MODESET))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2012-12-02 20:53:40 +00:00
|
|
|
fb = drm_framebuffer_lookup(dev, r->fb_id);
|
2012-12-10 23:38:18 +00:00
|
|
|
if (!fb)
|
2013-10-17 10:35:01 +00:00
|
|
|
return -ENOENT;
|
2009-12-03 23:25:47 +00:00
|
|
|
|
|
|
|
|
num_clips = r->num_clips;
|
2011-12-19 22:06:42 +00:00
|
|
|
clips_ptr = (struct drm_clip_rect __user *)(unsigned long)r->clips_ptr;
|
2009-12-03 23:25:47 +00:00
|
|
|
|
|
|
|
|
if (!num_clips != !clips_ptr) {
|
|
|
|
|
ret = -EINVAL;
|
|
|
|
|
goto out_err1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
flags = DRM_MODE_FB_DIRTY_FLAGS & r->flags;
|
|
|
|
|
|
|
|
|
|
/* If userspace annotates copy, clips must come in pairs */
|
|
|
|
|
if (flags & DRM_MODE_FB_DIRTY_ANNOTATE_COPY && (num_clips % 2)) {
|
|
|
|
|
ret = -EINVAL;
|
|
|
|
|
goto out_err1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (num_clips && clips_ptr) {
|
2011-11-23 06:12:01 +00:00
|
|
|
if (num_clips < 0 || num_clips > DRM_MODE_FB_DIRTY_MAX_CLIPS) {
|
|
|
|
|
ret = -EINVAL;
|
|
|
|
|
goto out_err1;
|
|
|
|
|
}
|
2009-12-03 23:25:47 +00:00
|
|
|
clips = kzalloc(num_clips * sizeof(*clips), GFP_KERNEL);
|
|
|
|
|
if (!clips) {
|
|
|
|
|
ret = -ENOMEM;
|
|
|
|
|
goto out_err1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ret = copy_from_user(clips, clips_ptr,
|
|
|
|
|
num_clips * sizeof(*clips));
|
2010-06-04 10:23:21 +00:00
|
|
|
if (ret) {
|
|
|
|
|
ret = -EFAULT;
|
2009-12-03 23:25:47 +00:00
|
|
|
goto out_err2;
|
2010-06-04 10:23:21 +00:00
|
|
|
}
|
2009-12-03 23:25:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (fb->funcs->dirty) {
|
2010-10-05 10:43:02 +00:00
|
|
|
ret = fb->funcs->dirty(fb, file_priv, flags, r->color,
|
|
|
|
|
clips, num_clips);
|
2009-12-03 23:25:47 +00:00
|
|
|
} else {
|
|
|
|
|
ret = -ENOSYS;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
out_err2:
|
|
|
|
|
kfree(clips);
|
|
|
|
|
out_err1:
|
2012-12-10 23:38:18 +00:00
|
|
|
drm_framebuffer_unreference(fb);
|
|
|
|
|
|
2009-12-03 23:25:47 +00:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2008-11-07 22:05:41 +00:00
|
|
|
/**
|
|
|
|
|
* drm_fb_release - remove and free the FBs on this file
|
2012-12-01 23:09:18 +00:00
|
|
|
* @priv: drm file for the ioctl
|
2008-11-07 22:05:41 +00:00
|
|
|
*
|
|
|
|
|
* Destroy all the FBs associated with @filp.
|
|
|
|
|
*
|
|
|
|
|
* Called by the user via ioctl.
|
|
|
|
|
*
|
2014-03-10 20:33:02 +00:00
|
|
|
* Returns:
|
2008-11-07 22:05:41 +00:00
|
|
|
* Zero on success, errno on failure.
|
|
|
|
|
*/
|
2009-02-12 19:37:56 +00:00
|
|
|
void drm_fb_release(struct drm_file *priv)
|
2008-11-07 22:05:41 +00:00
|
|
|
{
|
|
|
|
|
struct drm_device *dev = priv->minor->dev;
|
|
|
|
|
struct drm_framebuffer *fb, *tfb;
|
|
|
|
|
|
drm: revamp locking around fb creation/destruction
Well, at least step 1. The goal here is that framebuffer objects can
survive outside of the mode_config lock, with just a reference held
as protection. The first step to get there is to introduce a special
fb_lock which protects fb lookup, creation and destruction, to make
them appear atomic.
This new fb_lock can nest within the mode_config lock. But the idea is
(once the reference counting part is completed) that we only quickly
take that fb_lock to lookup a framebuffer and grab a reference,
without any other locks involved.
vmwgfx is the only driver which does framebuffer lookups itself, also
wrap those calls to drm_mode_object_find with the new lock.
Also protect the fb_list walking in i915 and omapdrm with the new lock.
As a slight complication there's also the list of user-created fbs
attached to the file private. The problem now is that at fclose() time
we need to walk that list, eventually do a modeset call to remove the
fb from active usage (and are required to be able to take the
mode_config lock), but in the end we need to grab the new fb_lock to
remove the fb from the list. The easiest solution is to add another
mutex to protect this per-file list.
Currently that new fbs_lock nests within the modeset locks and so
appears redudant. But later patches will switch around this sequence
so that taking the modeset locks in the fb destruction path is
optional in the fastpath. Ultimately the goal is that addfb and rmfb
do not require the mode_config lock, since otherwise they have the
potential to introduce stalls in the pageflip sequence of a compositor
(if the compositor e.g. switches to a fullscreen client or if it
enables a plane). But that requires a few more steps and hoops to jump
through.
Note that framebuffer creation/destruction is now double-protected -
once by the fb_lock and in parts by the idr_lock. The later would be
unnecessariy if framebuffers would have their own idr allocator. But
that's material for another patch (series).
v2: Properly initialize the fb->filp_head list in _init, otherwise the
newly added WARN to check whether the fb isn't on a fpriv list any
more will fail for driver-private objects.
v3: Fixup two error-case unlock bugs spotted by Richard Wilbur.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-10 20:19:18 +00:00
|
|
|
mutex_lock(&priv->fbs_lock);
|
2008-11-07 22:05:41 +00:00
|
|
|
list_for_each_entry_safe(fb, tfb, &priv->fbs, filp_head) {
|
drm: reference framebuffers which are on the idr
Since otherwise looking and reference-counting around
drm_framebuffer_lookup will be an unmanageable mess. With this change,
an object can either be found in the idr and will stay around once we
incremented the reference counter. Or it will be gone for good and
can't be looked up using its id any more.
Atomicity is guaranteed by the dev->mode_config.fb_lock. The
newly-introduce fpriv->fbs_lock looks a bit redundant, but the next
patch will shuffle the locking order between these two locks and all
the modeset locks taken in modeset_lock_all, so we'll need it.
Also, since userspace could do really funky stuff and race e.g. a
getresources with an rmfb, we need to make sure that the kernel
doesn't fall over trying to look-up an inexistent fb, or causing
confusion by having two fbs around with the same id. Simply reset the
framebuffer id to 0, which marks it as reaped. Any lookups of that id
will fail, so the object is really gone for good from userspace's pov.
Note that we still need to protect the "remove framebuffer from all
use-cases" and the final unreference with the modeset-lock, since most
framebuffer use-sites don't implement proper reference counting yet.
We can only lift this once _all_ users are converted.
With this change, two references are held on alife, but unused
framebuffers:
- The reference for the idr lookup, created in this patch.
- For user-created framebuffers the fpriv->fbs reference, for
driver-private fbs the driver is supposed to hold it's own last
reference.
Note that the dev->mode_config.fb_list itself does _not_ hold a
reference onto the framebuffers (this list is essentially only used
for debugfs files). Hence if there's anything left there when the
driver has cleaned up all it's modeset resources, this is a ref-leak.
WARN about it.
Now we only need to fix up all other places to properly reference
count framebuffers.
v2: Fix spelling fail in a comment spotted by Rob Clark.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-10 20:16:05 +00:00
|
|
|
|
|
|
|
|
mutex_lock(&dev->mode_config.fb_lock);
|
|
|
|
|
/* Mark fb as reaped, we still have a ref from fpriv->fbs. */
|
|
|
|
|
__drm_framebuffer_unregister(dev, fb);
|
|
|
|
|
mutex_unlock(&dev->mode_config.fb_lock);
|
|
|
|
|
|
drm: revamp locking around fb creation/destruction
Well, at least step 1. The goal here is that framebuffer objects can
survive outside of the mode_config lock, with just a reference held
as protection. The first step to get there is to introduce a special
fb_lock which protects fb lookup, creation and destruction, to make
them appear atomic.
This new fb_lock can nest within the mode_config lock. But the idea is
(once the reference counting part is completed) that we only quickly
take that fb_lock to lookup a framebuffer and grab a reference,
without any other locks involved.
vmwgfx is the only driver which does framebuffer lookups itself, also
wrap those calls to drm_mode_object_find with the new lock.
Also protect the fb_list walking in i915 and omapdrm with the new lock.
As a slight complication there's also the list of user-created fbs
attached to the file private. The problem now is that at fclose() time
we need to walk that list, eventually do a modeset call to remove the
fb from active usage (and are required to be able to take the
mode_config lock), but in the end we need to grab the new fb_lock to
remove the fb from the list. The easiest solution is to add another
mutex to protect this per-file list.
Currently that new fbs_lock nests within the modeset locks and so
appears redudant. But later patches will switch around this sequence
so that taking the modeset locks in the fb destruction path is
optional in the fastpath. Ultimately the goal is that addfb and rmfb
do not require the mode_config lock, since otherwise they have the
potential to introduce stalls in the pageflip sequence of a compositor
(if the compositor e.g. switches to a fullscreen client or if it
enables a plane). But that requires a few more steps and hoops to jump
through.
Note that framebuffer creation/destruction is now double-protected -
once by the fb_lock and in parts by the idr_lock. The later would be
unnecessariy if framebuffers would have their own idr allocator. But
that's material for another patch (series).
v2: Properly initialize the fb->filp_head list in _init, otherwise the
newly added WARN to check whether the fb isn't on a fpriv list any
more will fail for driver-private objects.
v3: Fixup two error-case unlock bugs spotted by Richard Wilbur.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-10 20:19:18 +00:00
|
|
|
list_del_init(&fb->filp_head);
|
drm: reference framebuffers which are on the idr
Since otherwise looking and reference-counting around
drm_framebuffer_lookup will be an unmanageable mess. With this change,
an object can either be found in the idr and will stay around once we
incremented the reference counter. Or it will be gone for good and
can't be looked up using its id any more.
Atomicity is guaranteed by the dev->mode_config.fb_lock. The
newly-introduce fpriv->fbs_lock looks a bit redundant, but the next
patch will shuffle the locking order between these two locks and all
the modeset locks taken in modeset_lock_all, so we'll need it.
Also, since userspace could do really funky stuff and race e.g. a
getresources with an rmfb, we need to make sure that the kernel
doesn't fall over trying to look-up an inexistent fb, or causing
confusion by having two fbs around with the same id. Simply reset the
framebuffer id to 0, which marks it as reaped. Any lookups of that id
will fail, so the object is really gone for good from userspace's pov.
Note that we still need to protect the "remove framebuffer from all
use-cases" and the final unreference with the modeset-lock, since most
framebuffer use-sites don't implement proper reference counting yet.
We can only lift this once _all_ users are converted.
With this change, two references are held on alife, but unused
framebuffers:
- The reference for the idr lookup, created in this patch.
- For user-created framebuffers the fpriv->fbs reference, for
driver-private fbs the driver is supposed to hold it's own last
reference.
Note that the dev->mode_config.fb_list itself does _not_ hold a
reference onto the framebuffers (this list is essentially only used
for debugfs files). Hence if there's anything left there when the
driver has cleaned up all it's modeset resources, this is a ref-leak.
WARN about it.
Now we only need to fix up all other places to properly reference
count framebuffers.
v2: Fix spelling fail in a comment spotted by Rob Clark.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-10 20:16:05 +00:00
|
|
|
|
|
|
|
|
/* This will also drop the fpriv->fbs reference. */
|
2012-09-05 21:48:38 +00:00
|
|
|
drm_framebuffer_remove(fb);
|
2008-11-07 22:05:41 +00:00
|
|
|
}
|
drm: revamp locking around fb creation/destruction
Well, at least step 1. The goal here is that framebuffer objects can
survive outside of the mode_config lock, with just a reference held
as protection. The first step to get there is to introduce a special
fb_lock which protects fb lookup, creation and destruction, to make
them appear atomic.
This new fb_lock can nest within the mode_config lock. But the idea is
(once the reference counting part is completed) that we only quickly
take that fb_lock to lookup a framebuffer and grab a reference,
without any other locks involved.
vmwgfx is the only driver which does framebuffer lookups itself, also
wrap those calls to drm_mode_object_find with the new lock.
Also protect the fb_list walking in i915 and omapdrm with the new lock.
As a slight complication there's also the list of user-created fbs
attached to the file private. The problem now is that at fclose() time
we need to walk that list, eventually do a modeset call to remove the
fb from active usage (and are required to be able to take the
mode_config lock), but in the end we need to grab the new fb_lock to
remove the fb from the list. The easiest solution is to add another
mutex to protect this per-file list.
Currently that new fbs_lock nests within the modeset locks and so
appears redudant. But later patches will switch around this sequence
so that taking the modeset locks in the fb destruction path is
optional in the fastpath. Ultimately the goal is that addfb and rmfb
do not require the mode_config lock, since otherwise they have the
potential to introduce stalls in the pageflip sequence of a compositor
(if the compositor e.g. switches to a fullscreen client or if it
enables a plane). But that requires a few more steps and hoops to jump
through.
Note that framebuffer creation/destruction is now double-protected -
once by the fb_lock and in parts by the idr_lock. The later would be
unnecessariy if framebuffers would have their own idr allocator. But
that's material for another patch (series).
v2: Properly initialize the fb->filp_head list in _init, otherwise the
newly added WARN to check whether the fb isn't on a fpriv list any
more will fail for driver-private objects.
v3: Fixup two error-case unlock bugs spotted by Richard Wilbur.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-10 20:19:18 +00:00
|
|
|
mutex_unlock(&priv->fbs_lock);
|
2008-11-07 22:05:41 +00:00
|
|
|
}
|
|
|
|
|
|
2014-03-10 20:33:02 +00:00
|
|
|
/**
|
|
|
|
|
* drm_property_create - create a new property type
|
|
|
|
|
* @dev: drm device
|
|
|
|
|
* @flags: flags specifying the property type
|
|
|
|
|
* @name: name of the property
|
|
|
|
|
* @num_values: number of pre-defined values
|
|
|
|
|
*
|
|
|
|
|
* This creates a new generic drm property which can then be attached to a drm
|
|
|
|
|
* object with drm_object_attach_property. The returned property object must be
|
|
|
|
|
* freed with drm_property_destroy.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* A pointer to the newly created property on success, NULL on failure.
|
|
|
|
|
*/
|
2008-11-07 22:05:41 +00:00
|
|
|
struct drm_property *drm_property_create(struct drm_device *dev, int flags,
|
|
|
|
|
const char *name, int num_values)
|
|
|
|
|
{
|
|
|
|
|
struct drm_property *property = NULL;
|
2012-03-13 10:35:48 +00:00
|
|
|
int ret;
|
2008-11-07 22:05:41 +00:00
|
|
|
|
|
|
|
|
property = kzalloc(sizeof(struct drm_property), GFP_KERNEL);
|
|
|
|
|
if (!property)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
2014-05-30 15:37:03 +00:00
|
|
|
property->dev = dev;
|
|
|
|
|
|
2008-11-07 22:05:41 +00:00
|
|
|
if (num_values) {
|
|
|
|
|
property->values = kzalloc(sizeof(uint64_t)*num_values, GFP_KERNEL);
|
|
|
|
|
if (!property->values)
|
|
|
|
|
goto fail;
|
|
|
|
|
}
|
|
|
|
|
|
2012-03-13 10:35:48 +00:00
|
|
|
ret = drm_mode_object_get(dev, &property->base, DRM_MODE_OBJECT_PROPERTY);
|
|
|
|
|
if (ret)
|
|
|
|
|
goto fail;
|
|
|
|
|
|
2008-11-07 22:05:41 +00:00
|
|
|
property->flags = flags;
|
|
|
|
|
property->num_values = num_values;
|
|
|
|
|
INIT_LIST_HEAD(&property->enum_blob_list);
|
|
|
|
|
|
2011-11-10 19:55:40 +00:00
|
|
|
if (name) {
|
2008-11-07 22:05:41 +00:00
|
|
|
strncpy(property->name, name, DRM_PROP_NAME_LEN);
|
2011-11-10 19:55:40 +00:00
|
|
|
property->name[DRM_PROP_NAME_LEN-1] = '\0';
|
|
|
|
|
}
|
2008-11-07 22:05:41 +00:00
|
|
|
|
|
|
|
|
list_add_tail(&property->head, &dev->mode_config.property_list);
|
2014-05-30 15:34:01 +00:00
|
|
|
|
|
|
|
|
WARN_ON(!drm_property_type_valid(property));
|
|
|
|
|
|
2008-11-07 22:05:41 +00:00
|
|
|
return property;
|
|
|
|
|
fail:
|
2012-03-13 10:35:48 +00:00
|
|
|
kfree(property->values);
|
2008-11-07 22:05:41 +00:00
|
|
|
kfree(property);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(drm_property_create);
|
|
|
|
|
|
2014-03-10 20:33:02 +00:00
|
|
|
/**
|
|
|
|
|
* drm_property_create - create a new enumeration property type
|
|
|
|
|
* @dev: drm device
|
|
|
|
|
* @flags: flags specifying the property type
|
|
|
|
|
* @name: name of the property
|
|
|
|
|
* @props: enumeration lists with property values
|
|
|
|
|
* @num_values: number of pre-defined values
|
|
|
|
|
*
|
|
|
|
|
* This creates a new generic drm property which can then be attached to a drm
|
|
|
|
|
* object with drm_object_attach_property. The returned property object must be
|
|
|
|
|
* freed with drm_property_destroy.
|
|
|
|
|
*
|
|
|
|
|
* Userspace is only allowed to set one of the predefined values for enumeration
|
|
|
|
|
* properties.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* A pointer to the newly created property on success, NULL on failure.
|
|
|
|
|
*/
|
2012-02-06 09:58:17 +00:00
|
|
|
struct drm_property *drm_property_create_enum(struct drm_device *dev, int flags,
|
|
|
|
|
const char *name,
|
|
|
|
|
const struct drm_prop_enum_list *props,
|
|
|
|
|
int num_values)
|
|
|
|
|
{
|
|
|
|
|
struct drm_property *property;
|
|
|
|
|
int i, ret;
|
|
|
|
|
|
|
|
|
|
flags |= DRM_MODE_PROP_ENUM;
|
|
|
|
|
|
|
|
|
|
property = drm_property_create(dev, flags, name, num_values);
|
|
|
|
|
if (!property)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < num_values; i++) {
|
|
|
|
|
ret = drm_property_add_enum(property, i,
|
|
|
|
|
props[i].type,
|
|
|
|
|
props[i].name);
|
|
|
|
|
if (ret) {
|
|
|
|
|
drm_property_destroy(dev, property);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return property;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(drm_property_create_enum);
|
|
|
|
|
|
2014-03-10 20:33:02 +00:00
|
|
|
/**
|
|
|
|
|
* drm_property_create - create a new bitmask property type
|
|
|
|
|
* @dev: drm device
|
|
|
|
|
* @flags: flags specifying the property type
|
|
|
|
|
* @name: name of the property
|
|
|
|
|
* @props: enumeration lists with property bitflags
|
|
|
|
|
* @num_values: number of pre-defined values
|
|
|
|
|
*
|
|
|
|
|
* This creates a new generic drm property which can then be attached to a drm
|
|
|
|
|
* object with drm_object_attach_property. The returned property object must be
|
|
|
|
|
* freed with drm_property_destroy.
|
|
|
|
|
*
|
|
|
|
|
* Compared to plain enumeration properties userspace is allowed to set any
|
|
|
|
|
* or'ed together combination of the predefined property bitflag values
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* A pointer to the newly created property on success, NULL on failure.
|
|
|
|
|
*/
|
2012-05-17 08:23:26 +00:00
|
|
|
struct drm_property *drm_property_create_bitmask(struct drm_device *dev,
|
|
|
|
|
int flags, const char *name,
|
|
|
|
|
const struct drm_prop_enum_list *props,
|
|
|
|
|
int num_values)
|
|
|
|
|
{
|
|
|
|
|
struct drm_property *property;
|
|
|
|
|
int i, ret;
|
|
|
|
|
|
|
|
|
|
flags |= DRM_MODE_PROP_BITMASK;
|
|
|
|
|
|
|
|
|
|
property = drm_property_create(dev, flags, name, num_values);
|
|
|
|
|
if (!property)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < num_values; i++) {
|
|
|
|
|
ret = drm_property_add_enum(property, i,
|
|
|
|
|
props[i].type,
|
|
|
|
|
props[i].name);
|
|
|
|
|
if (ret) {
|
|
|
|
|
drm_property_destroy(dev, property);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return property;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(drm_property_create_bitmask);
|
|
|
|
|
|
2012-09-13 03:22:31 +00:00
|
|
|
static struct drm_property *property_create_range(struct drm_device *dev,
|
|
|
|
|
int flags, const char *name,
|
|
|
|
|
uint64_t min, uint64_t max)
|
|
|
|
|
{
|
|
|
|
|
struct drm_property *property;
|
|
|
|
|
|
|
|
|
|
property = drm_property_create(dev, flags, name, 2);
|
|
|
|
|
if (!property)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
property->values[0] = min;
|
|
|
|
|
property->values[1] = max;
|
|
|
|
|
|
|
|
|
|
return property;
|
|
|
|
|
}
|
|
|
|
|
|
2014-03-10 20:33:02 +00:00
|
|
|
/**
|
|
|
|
|
* drm_property_create - create a new ranged property type
|
|
|
|
|
* @dev: drm device
|
|
|
|
|
* @flags: flags specifying the property type
|
|
|
|
|
* @name: name of the property
|
|
|
|
|
* @min: minimum value of the property
|
|
|
|
|
* @max: maximum value of the property
|
|
|
|
|
*
|
|
|
|
|
* This creates a new generic drm property which can then be attached to a drm
|
|
|
|
|
* object with drm_object_attach_property. The returned property object must be
|
|
|
|
|
* freed with drm_property_destroy.
|
|
|
|
|
*
|
|
|
|
|
* Userspace is allowed to set any interger value in the (min, max) range
|
|
|
|
|
* inclusive.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* A pointer to the newly created property on success, NULL on failure.
|
|
|
|
|
*/
|
2012-02-06 09:58:18 +00: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 03:22:31 +00:00
|
|
|
return property_create_range(dev, DRM_MODE_PROP_RANGE | flags,
|
|
|
|
|
name, min, max);
|
2012-02-06 09:58:18 +00:00
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(drm_property_create_range);
|
|
|
|
|
|
2012-09-13 03:22:31 +00:00
|
|
|
struct drm_property *drm_property_create_signed_range(struct drm_device *dev,
|
|
|
|
|
int flags, const char *name,
|
|
|
|
|
int64_t min, int64_t max)
|
|
|
|
|
{
|
|
|
|
|
return property_create_range(dev, DRM_MODE_PROP_SIGNED_RANGE | flags,
|
|
|
|
|
name, I642U64(min), I642U64(max));
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(drm_property_create_signed_range);
|
|
|
|
|
|
2014-05-30 15:37:03 +00:00
|
|
|
struct drm_property *drm_property_create_object(struct drm_device *dev,
|
|
|
|
|
int flags, const char *name, uint32_t type)
|
|
|
|
|
{
|
|
|
|
|
struct drm_property *property;
|
|
|
|
|
|
|
|
|
|
flags |= DRM_MODE_PROP_OBJECT;
|
|
|
|
|
|
|
|
|
|
property = drm_property_create(dev, flags, name, 1);
|
|
|
|
|
if (!property)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
property->values[0] = type;
|
|
|
|
|
|
|
|
|
|
return property;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(drm_property_create_object);
|
|
|
|
|
|
2014-03-10 20:33:02 +00:00
|
|
|
/**
|
|
|
|
|
* drm_property_add_enum - add a possible value to an enumeration property
|
|
|
|
|
* @property: enumeration property to change
|
|
|
|
|
* @index: index of the new enumeration
|
|
|
|
|
* @value: value of the new enumeration
|
|
|
|
|
* @name: symbolic name of the new enumeration
|
|
|
|
|
*
|
|
|
|
|
* This functions adds enumerations to a property.
|
|
|
|
|
*
|
|
|
|
|
* It's use is deprecated, drivers should use one of the more specific helpers
|
|
|
|
|
* to directly create the property with all enumerations already attached.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* Zero on success, error code on failure.
|
|
|
|
|
*/
|
2008-11-07 22:05:41 +00:00
|
|
|
int drm_property_add_enum(struct drm_property *property, int index,
|
|
|
|
|
uint64_t value, const char *name)
|
|
|
|
|
{
|
|
|
|
|
struct drm_property_enum *prop_enum;
|
|
|
|
|
|
2014-05-30 15:34:01 +00:00
|
|
|
if (!(drm_property_type_is(property, DRM_MODE_PROP_ENUM) ||
|
|
|
|
|
drm_property_type_is(property, DRM_MODE_PROP_BITMASK)))
|
2012-05-17 08:23:26 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Bitmask enum properties have the additional constraint of values
|
|
|
|
|
* from 0 to 63
|
|
|
|
|
*/
|
2014-05-30 15:34:01 +00:00
|
|
|
if (drm_property_type_is(property, DRM_MODE_PROP_BITMASK) &&
|
|
|
|
|
(value > 63))
|
2008-11-07 22:05:41 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
if (!list_empty(&property->enum_blob_list)) {
|
|
|
|
|
list_for_each_entry(prop_enum, &property->enum_blob_list, head) {
|
|
|
|
|
if (prop_enum->value == value) {
|
|
|
|
|
strncpy(prop_enum->name, name, DRM_PROP_NAME_LEN);
|
|
|
|
|
prop_enum->name[DRM_PROP_NAME_LEN-1] = '\0';
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
prop_enum = kzalloc(sizeof(struct drm_property_enum), GFP_KERNEL);
|
|
|
|
|
if (!prop_enum)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
|
|
strncpy(prop_enum->name, name, DRM_PROP_NAME_LEN);
|
|
|
|
|
prop_enum->name[DRM_PROP_NAME_LEN-1] = '\0';
|
|
|
|
|
prop_enum->value = value;
|
|
|
|
|
|
|
|
|
|
property->values[index] = value;
|
|
|
|
|
list_add_tail(&prop_enum->head, &property->enum_blob_list);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(drm_property_add_enum);
|
|
|
|
|
|
2014-03-10 20:33:02 +00:00
|
|
|
/**
|
|
|
|
|
* drm_property_destroy - destroy a drm property
|
|
|
|
|
* @dev: drm device
|
|
|
|
|
* @property: property to destry
|
|
|
|
|
*
|
|
|
|
|
* This function frees a property including any attached resources like
|
|
|
|
|
* enumeration values.
|
|
|
|
|
*/
|
2008-11-07 22:05:41 +00:00
|
|
|
void drm_property_destroy(struct drm_device *dev, struct drm_property *property)
|
|
|
|
|
{
|
|
|
|
|
struct drm_property_enum *prop_enum, *pt;
|
|
|
|
|
|
|
|
|
|
list_for_each_entry_safe(prop_enum, pt, &property->enum_blob_list, head) {
|
|
|
|
|
list_del(&prop_enum->head);
|
|
|
|
|
kfree(prop_enum);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (property->num_values)
|
|
|
|
|
kfree(property->values);
|
|
|
|
|
drm_mode_object_put(dev, &property->base);
|
|
|
|
|
list_del(&property->head);
|
|
|
|
|
kfree(property);
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(drm_property_destroy);
|
|
|
|
|
|
2014-03-10 20:33:02 +00:00
|
|
|
/**
|
|
|
|
|
* drm_object_attach_property - attach a property to a modeset object
|
|
|
|
|
* @obj: drm modeset object
|
|
|
|
|
* @property: property to attach
|
|
|
|
|
* @init_val: initial value of the property
|
|
|
|
|
*
|
|
|
|
|
* This attaches the given property to the modeset object with the given initial
|
|
|
|
|
* value. Currently this function cannot fail since the properties are stored in
|
|
|
|
|
* a statically sized array.
|
|
|
|
|
*/
|
2012-05-15 21:09:02 +00:00
|
|
|
void drm_object_attach_property(struct drm_mode_object *obj,
|
|
|
|
|
struct drm_property *property,
|
|
|
|
|
uint64_t init_val)
|
|
|
|
|
{
|
2012-05-15 21:09:04 +00:00
|
|
|
int count = obj->properties->count;
|
2012-05-15 21:09:02 +00:00
|
|
|
|
2012-05-15 21:09:04 +00:00
|
|
|
if (count == DRM_OBJECT_MAX_PROPERTY) {
|
|
|
|
|
WARN(1, "Failed to attach object property (type: 0x%x). Please "
|
|
|
|
|
"increase DRM_OBJECT_MAX_PROPERTY by 1 for each time "
|
|
|
|
|
"you see this message on the same object type.\n",
|
|
|
|
|
obj->type);
|
|
|
|
|
return;
|
2012-05-15 21:09:02 +00:00
|
|
|
}
|
|
|
|
|
|
2012-05-15 21:09:04 +00:00
|
|
|
obj->properties->ids[count] = property->base.id;
|
|
|
|
|
obj->properties->values[count] = init_val;
|
|
|
|
|
obj->properties->count++;
|
2012-05-15 21:09:02 +00:00
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(drm_object_attach_property);
|
|
|
|
|
|
2014-03-10 20:33:02 +00:00
|
|
|
/**
|
|
|
|
|
* drm_object_property_set_value - set the value of a property
|
|
|
|
|
* @obj: drm mode object to set property value for
|
|
|
|
|
* @property: property to set
|
|
|
|
|
* @val: value the property should be set to
|
|
|
|
|
*
|
|
|
|
|
* This functions sets a given property on a given object. This function only
|
|
|
|
|
* changes the software state of the property, it does not call into the
|
|
|
|
|
* driver's ->set_property callback.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* Zero on success, error code on failure.
|
|
|
|
|
*/
|
2012-05-15 21:09:02 +00:00
|
|
|
int drm_object_property_set_value(struct drm_mode_object *obj,
|
|
|
|
|
struct drm_property *property, uint64_t val)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
|
2012-05-15 21:09:04 +00:00
|
|
|
for (i = 0; i < obj->properties->count; i++) {
|
2012-05-15 21:09:02 +00:00
|
|
|
if (obj->properties->ids[i] == property->base.id) {
|
|
|
|
|
obj->properties->values[i] = val;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(drm_object_property_set_value);
|
|
|
|
|
|
2014-03-10 20:33:02 +00:00
|
|
|
/**
|
|
|
|
|
* drm_object_property_get_value - retrieve the value of a property
|
|
|
|
|
* @obj: drm mode object to get property value from
|
|
|
|
|
* @property: property to retrieve
|
|
|
|
|
* @val: storage for the property value
|
|
|
|
|
*
|
|
|
|
|
* This function retrieves the softare state of the given property for the given
|
|
|
|
|
* property. Since there is no driver callback to retrieve the current property
|
|
|
|
|
* value this might be out of sync with the hardware, depending upon the driver
|
|
|
|
|
* and property.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* Zero on success, error code on failure.
|
|
|
|
|
*/
|
2012-05-15 21:09:02 +00:00
|
|
|
int drm_object_property_get_value(struct drm_mode_object *obj,
|
|
|
|
|
struct drm_property *property, uint64_t *val)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
|
2012-05-15 21:09:04 +00:00
|
|
|
for (i = 0; i < obj->properties->count; i++) {
|
2012-05-15 21:09:02 +00:00
|
|
|
if (obj->properties->ids[i] == property->base.id) {
|
|
|
|
|
*val = obj->properties->values[i];
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(drm_object_property_get_value);
|
|
|
|
|
|
2014-03-10 20:33:02 +00:00
|
|
|
/**
|
|
|
|
|
* drm_mode_getproperty_ioctl - get the current value of a connector's property
|
|
|
|
|
* @dev: DRM device
|
|
|
|
|
* @data: ioctl data
|
|
|
|
|
* @file_priv: DRM file info
|
|
|
|
|
*
|
|
|
|
|
* This function retrieves the current value for an connectors's property.
|
|
|
|
|
*
|
|
|
|
|
* Called by the user via ioctl.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* Zero on success, errno on failure.
|
|
|
|
|
*/
|
2008-11-07 22:05:41 +00:00
|
|
|
int drm_mode_getproperty_ioctl(struct drm_device *dev,
|
|
|
|
|
void *data, struct drm_file *file_priv)
|
|
|
|
|
{
|
|
|
|
|
struct drm_mode_get_property *out_resp = data;
|
|
|
|
|
struct drm_property *property;
|
|
|
|
|
int enum_count = 0;
|
|
|
|
|
int blob_count = 0;
|
|
|
|
|
int value_count = 0;
|
|
|
|
|
int ret = 0, i;
|
|
|
|
|
int copied;
|
|
|
|
|
struct drm_property_enum *prop_enum;
|
|
|
|
|
struct drm_mode_property_enum __user *enum_ptr;
|
|
|
|
|
struct drm_property_blob *prop_blob;
|
2011-12-19 22:06:42 +00:00
|
|
|
uint32_t __user *blob_id_ptr;
|
2008-11-07 22:05:41 +00:00
|
|
|
uint64_t __user *values_ptr;
|
|
|
|
|
uint32_t __user *blob_length_ptr;
|
|
|
|
|
|
2011-02-08 03:55:21 +00:00
|
|
|
if (!drm_core_check_feature(dev, DRIVER_MODESET))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2012-12-01 23:28:11 +00:00
|
|
|
drm_modeset_lock_all(dev);
|
2013-10-05 20:36:52 +00:00
|
|
|
property = drm_property_find(dev, out_resp->prop_id);
|
|
|
|
|
if (!property) {
|
2013-10-17 10:35:00 +00:00
|
|
|
ret = -ENOENT;
|
2008-11-07 22:05:41 +00:00
|
|
|
goto done;
|
|
|
|
|
}
|
|
|
|
|
|
2014-05-30 15:34:01 +00:00
|
|
|
if (drm_property_type_is(property, DRM_MODE_PROP_ENUM) ||
|
|
|
|
|
drm_property_type_is(property, DRM_MODE_PROP_BITMASK)) {
|
2008-11-07 22:05:41 +00:00
|
|
|
list_for_each_entry(prop_enum, &property->enum_blob_list, head)
|
|
|
|
|
enum_count++;
|
2014-05-30 15:34:01 +00:00
|
|
|
} else if (drm_property_type_is(property, DRM_MODE_PROP_BLOB)) {
|
2008-11-07 22:05:41 +00:00
|
|
|
list_for_each_entry(prop_blob, &property->enum_blob_list, head)
|
|
|
|
|
blob_count++;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
value_count = property->num_values;
|
|
|
|
|
|
|
|
|
|
strncpy(out_resp->name, property->name, DRM_PROP_NAME_LEN);
|
|
|
|
|
out_resp->name[DRM_PROP_NAME_LEN-1] = 0;
|
|
|
|
|
out_resp->flags = property->flags;
|
|
|
|
|
|
|
|
|
|
if ((out_resp->count_values >= value_count) && value_count) {
|
2011-12-19 22:06:42 +00:00
|
|
|
values_ptr = (uint64_t __user *)(unsigned long)out_resp->values_ptr;
|
2008-11-07 22:05:41 +00:00
|
|
|
for (i = 0; i < value_count; i++) {
|
|
|
|
|
if (copy_to_user(values_ptr + i, &property->values[i], sizeof(uint64_t))) {
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
goto done;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
out_resp->count_values = value_count;
|
|
|
|
|
|
2014-05-30 15:34:01 +00:00
|
|
|
if (drm_property_type_is(property, DRM_MODE_PROP_ENUM) ||
|
|
|
|
|
drm_property_type_is(property, DRM_MODE_PROP_BITMASK)) {
|
2008-11-07 22:05:41 +00:00
|
|
|
if ((out_resp->count_enum_blobs >= enum_count) && enum_count) {
|
|
|
|
|
copied = 0;
|
2011-12-19 22:06:42 +00:00
|
|
|
enum_ptr = (struct drm_mode_property_enum __user *)(unsigned long)out_resp->enum_blob_ptr;
|
2008-11-07 22:05:41 +00:00
|
|
|
list_for_each_entry(prop_enum, &property->enum_blob_list, head) {
|
|
|
|
|
|
|
|
|
|
if (copy_to_user(&enum_ptr[copied].value, &prop_enum->value, sizeof(uint64_t))) {
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
goto done;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (copy_to_user(&enum_ptr[copied].name,
|
|
|
|
|
&prop_enum->name, DRM_PROP_NAME_LEN)) {
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
goto done;
|
|
|
|
|
}
|
|
|
|
|
copied++;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
out_resp->count_enum_blobs = enum_count;
|
|
|
|
|
}
|
|
|
|
|
|
2014-05-30 15:34:01 +00:00
|
|
|
if (drm_property_type_is(property, DRM_MODE_PROP_BLOB)) {
|
2008-11-07 22:05:41 +00:00
|
|
|
if ((out_resp->count_enum_blobs >= blob_count) && blob_count) {
|
|
|
|
|
copied = 0;
|
2011-12-19 22:06:42 +00:00
|
|
|
blob_id_ptr = (uint32_t __user *)(unsigned long)out_resp->enum_blob_ptr;
|
|
|
|
|
blob_length_ptr = (uint32_t __user *)(unsigned long)out_resp->values_ptr;
|
2008-11-07 22:05:41 +00:00
|
|
|
|
|
|
|
|
list_for_each_entry(prop_blob, &property->enum_blob_list, head) {
|
|
|
|
|
if (put_user(prop_blob->base.id, blob_id_ptr + copied)) {
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
goto done;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (put_user(prop_blob->length, blob_length_ptr + copied)) {
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
goto done;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
copied++;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
out_resp->count_enum_blobs = blob_count;
|
|
|
|
|
}
|
|
|
|
|
done:
|
2012-12-01 23:28:11 +00:00
|
|
|
drm_modeset_unlock_all(dev);
|
2008-11-07 22:05:41 +00:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static struct drm_property_blob *drm_property_create_blob(struct drm_device *dev, int length,
|
|
|
|
|
void *data)
|
|
|
|
|
{
|
|
|
|
|
struct drm_property_blob *blob;
|
2012-03-13 10:35:48 +00:00
|
|
|
int ret;
|
2008-11-07 22:05:41 +00:00
|
|
|
|
|
|
|
|
if (!length || !data)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
blob = kzalloc(sizeof(struct drm_property_blob)+length, GFP_KERNEL);
|
|
|
|
|
if (!blob)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
2012-03-13 10:35:48 +00:00
|
|
|
ret = drm_mode_object_get(dev, &blob->base, DRM_MODE_OBJECT_BLOB);
|
|
|
|
|
if (ret) {
|
|
|
|
|
kfree(blob);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2008-11-07 22:05:41 +00:00
|
|
|
blob->length = length;
|
|
|
|
|
|
|
|
|
|
memcpy(blob->data, data, length);
|
|
|
|
|
|
|
|
|
|
list_add_tail(&blob->head, &dev->mode_config.property_blob_list);
|
|
|
|
|
return blob;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void drm_property_destroy_blob(struct drm_device *dev,
|
|
|
|
|
struct drm_property_blob *blob)
|
|
|
|
|
{
|
|
|
|
|
drm_mode_object_put(dev, &blob->base);
|
|
|
|
|
list_del(&blob->head);
|
|
|
|
|
kfree(blob);
|
|
|
|
|
}
|
|
|
|
|
|
2014-03-10 20:33:02 +00:00
|
|
|
/**
|
|
|
|
|
* drm_mode_getblob_ioctl - get the contents of a blob property value
|
|
|
|
|
* @dev: DRM device
|
|
|
|
|
* @data: ioctl data
|
|
|
|
|
* @file_priv: DRM file info
|
|
|
|
|
*
|
|
|
|
|
* This function retrieves the contents of a blob property. The value stored in
|
|
|
|
|
* an object's blob property is just a normal modeset object id.
|
|
|
|
|
*
|
|
|
|
|
* Called by the user via ioctl.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* Zero on success, errno on failure.
|
|
|
|
|
*/
|
2008-11-07 22:05:41 +00:00
|
|
|
int drm_mode_getblob_ioctl(struct drm_device *dev,
|
|
|
|
|
void *data, struct drm_file *file_priv)
|
|
|
|
|
{
|
|
|
|
|
struct drm_mode_get_blob *out_resp = data;
|
|
|
|
|
struct drm_property_blob *blob;
|
|
|
|
|
int ret = 0;
|
2011-12-19 22:06:42 +00:00
|
|
|
void __user *blob_ptr;
|
2008-11-07 22:05:41 +00:00
|
|
|
|
2011-02-08 03:55:21 +00:00
|
|
|
if (!drm_core_check_feature(dev, DRIVER_MODESET))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2012-12-01 23:28:11 +00:00
|
|
|
drm_modeset_lock_all(dev);
|
2013-10-05 20:36:52 +00:00
|
|
|
blob = drm_property_blob_find(dev, out_resp->blob_id);
|
|
|
|
|
if (!blob) {
|
2013-10-17 10:35:00 +00:00
|
|
|
ret = -ENOENT;
|
2008-11-07 22:05:41 +00:00
|
|
|
goto done;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (out_resp->length == blob->length) {
|
2011-12-19 22:06:42 +00:00
|
|
|
blob_ptr = (void __user *)(unsigned long)out_resp->data;
|
2008-11-07 22:05:41 +00:00
|
|
|
if (copy_to_user(blob_ptr, blob->data, blob->length)){
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
goto done;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
out_resp->length = blob->length;
|
|
|
|
|
|
|
|
|
|
done:
|
2012-12-01 23:28:11 +00:00
|
|
|
drm_modeset_unlock_all(dev);
|
2008-11-07 22:05:41 +00:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2014-03-10 20:33:02 +00:00
|
|
|
/**
|
|
|
|
|
* drm_mode_connector_update_edid_property - update the edid property of a connector
|
|
|
|
|
* @connector: drm connector
|
|
|
|
|
* @edid: new value of the edid property
|
|
|
|
|
*
|
|
|
|
|
* This function creates a new blob modeset object and assigns its id to the
|
|
|
|
|
* connector's edid property.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* Zero on success, errno on failure.
|
|
|
|
|
*/
|
2008-11-07 22:05:41 +00:00
|
|
|
int drm_mode_connector_update_edid_property(struct drm_connector *connector,
|
|
|
|
|
struct edid *edid)
|
|
|
|
|
{
|
|
|
|
|
struct drm_device *dev = connector->dev;
|
2012-05-17 11:27:21 +00:00
|
|
|
int ret, size;
|
2008-11-07 22:05:41 +00:00
|
|
|
|
|
|
|
|
if (connector->edid_blob_ptr)
|
|
|
|
|
drm_property_destroy_blob(dev, connector->edid_blob_ptr);
|
|
|
|
|
|
|
|
|
|
/* Delete edid, when there is none. */
|
|
|
|
|
if (!edid) {
|
|
|
|
|
connector->edid_blob_ptr = NULL;
|
2012-10-12 01:50:56 +00:00
|
|
|
ret = drm_object_property_set_value(&connector->base, dev->mode_config.edid_property, 0);
|
2008-11-07 22:05:41 +00:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2010-03-29 21:43:23 +00:00
|
|
|
size = EDID_LENGTH * (1 + edid->extensions);
|
|
|
|
|
connector->edid_blob_ptr = drm_property_create_blob(connector->dev,
|
|
|
|
|
size, edid);
|
2012-11-19 09:44:57 +00:00
|
|
|
if (!connector->edid_blob_ptr)
|
|
|
|
|
return -EINVAL;
|
2008-11-07 22:05:41 +00:00
|
|
|
|
2012-10-12 01:50:56 +00:00
|
|
|
ret = drm_object_property_set_value(&connector->base,
|
2008-11-07 22:05:41 +00:00
|
|
|
dev->mode_config.edid_property,
|
|
|
|
|
connector->edid_blob_ptr->base.id);
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(drm_mode_connector_update_edid_property);
|
|
|
|
|
|
2012-05-15 21:08:59 +00:00
|
|
|
static bool drm_property_change_is_valid(struct drm_property *property,
|
2012-05-24 17:53:58 +00:00
|
|
|
uint64_t value)
|
2012-05-15 21:08:59 +00:00
|
|
|
{
|
|
|
|
|
if (property->flags & DRM_MODE_PROP_IMMUTABLE)
|
|
|
|
|
return false;
|
2014-05-30 15:34:01 +00:00
|
|
|
|
|
|
|
|
if (drm_property_type_is(property, DRM_MODE_PROP_RANGE)) {
|
2012-05-15 21:08:59 +00:00
|
|
|
if (value < property->values[0] || value > property->values[1])
|
|
|
|
|
return false;
|
|
|
|
|
return true;
|
2012-09-13 03:22:31 +00:00
|
|
|
} else if (drm_property_type_is(property, DRM_MODE_PROP_SIGNED_RANGE)) {
|
|
|
|
|
int64_t svalue = U642I64(value);
|
|
|
|
|
if (svalue < U642I64(property->values[0]) ||
|
|
|
|
|
svalue > U642I64(property->values[1]))
|
|
|
|
|
return false;
|
|
|
|
|
return true;
|
2014-05-30 15:34:01 +00:00
|
|
|
} else if (drm_property_type_is(property, DRM_MODE_PROP_BITMASK)) {
|
2012-05-17 08:23:26 +00:00
|
|
|
int i;
|
2012-05-24 17:53:58 +00:00
|
|
|
uint64_t valid_mask = 0;
|
2012-05-17 08:23:26 +00:00
|
|
|
for (i = 0; i < property->num_values; i++)
|
|
|
|
|
valid_mask |= (1ULL << property->values[i]);
|
|
|
|
|
return !(value & ~valid_mask);
|
2014-05-30 15:34:01 +00:00
|
|
|
} else if (drm_property_type_is(property, DRM_MODE_PROP_BLOB)) {
|
2012-10-25 18:05:06 +00:00
|
|
|
/* Only the driver knows */
|
|
|
|
|
return true;
|
2014-05-30 15:37:03 +00:00
|
|
|
} else if (drm_property_type_is(property, DRM_MODE_PROP_OBJECT)) {
|
|
|
|
|
struct drm_mode_object *obj;
|
|
|
|
|
/* a zero value for an object property translates to null: */
|
|
|
|
|
if (value == 0)
|
|
|
|
|
return true;
|
|
|
|
|
/*
|
|
|
|
|
* NOTE: use _object_find() directly to bypass restriction on
|
|
|
|
|
* looking up refcnt'd objects (ie. fb's). For a refcnt'd
|
|
|
|
|
* object this could race against object finalization, so it
|
|
|
|
|
* simply tells us that the object *was* valid. Which is good
|
|
|
|
|
* enough.
|
|
|
|
|
*/
|
|
|
|
|
obj = _object_find(property->dev, value, property->values[0]);
|
|
|
|
|
return obj != NULL;
|
2012-05-15 21:08:59 +00:00
|
|
|
} else {
|
|
|
|
|
int i;
|
|
|
|
|
for (i = 0; i < property->num_values; i++)
|
|
|
|
|
if (property->values[i] == value)
|
|
|
|
|
return true;
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2014-03-10 20:33:02 +00:00
|
|
|
/**
|
|
|
|
|
* drm_mode_connector_property_set_ioctl - set the current value of a connector property
|
|
|
|
|
* @dev: DRM device
|
|
|
|
|
* @data: ioctl data
|
|
|
|
|
* @file_priv: DRM file info
|
|
|
|
|
*
|
|
|
|
|
* This function sets the current value for a connectors's property. It also
|
|
|
|
|
* calls into a driver's ->set_property callback to update the hardware state
|
|
|
|
|
*
|
|
|
|
|
* Called by the user via ioctl.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* Zero on success, errno on failure.
|
|
|
|
|
*/
|
2008-11-07 22:05:41 +00:00
|
|
|
int drm_mode_connector_property_set_ioctl(struct drm_device *dev,
|
|
|
|
|
void *data, struct drm_file *file_priv)
|
|
|
|
|
{
|
2012-05-15 21:09:03 +00:00
|
|
|
struct drm_mode_connector_set_property *conn_set_prop = data;
|
|
|
|
|
struct drm_mode_obj_set_property obj_set_prop = {
|
|
|
|
|
.value = conn_set_prop->value,
|
|
|
|
|
.prop_id = conn_set_prop->prop_id,
|
|
|
|
|
.obj_id = conn_set_prop->connector_id,
|
|
|
|
|
.obj_type = DRM_MODE_OBJECT_CONNECTOR
|
|
|
|
|
};
|
2011-02-08 03:55:21 +00:00
|
|
|
|
2012-05-15 21:09:03 +00:00
|
|
|
/* It does all the locking and checking we need */
|
|
|
|
|
return drm_mode_obj_set_property_ioctl(dev, &obj_set_prop, file_priv);
|
2008-11-07 22:05:41 +00:00
|
|
|
}
|
|
|
|
|
|
2012-05-15 21:09:02 +00:00
|
|
|
static int drm_mode_connector_set_obj_prop(struct drm_mode_object *obj,
|
|
|
|
|
struct drm_property *property,
|
|
|
|
|
uint64_t value)
|
|
|
|
|
{
|
|
|
|
|
int ret = -EINVAL;
|
|
|
|
|
struct drm_connector *connector = obj_to_connector(obj);
|
|
|
|
|
|
|
|
|
|
/* Do DPMS ourselves */
|
|
|
|
|
if (property == connector->dev->mode_config.dpms_property) {
|
|
|
|
|
if (connector->funcs->dpms)
|
|
|
|
|
(*connector->funcs->dpms)(connector, (int)value);
|
|
|
|
|
ret = 0;
|
|
|
|
|
} else if (connector->funcs->set_property)
|
|
|
|
|
ret = connector->funcs->set_property(connector, property, value);
|
|
|
|
|
|
|
|
|
|
/* store the property value if successful */
|
|
|
|
|
if (!ret)
|
2012-10-12 01:50:56 +00:00
|
|
|
drm_object_property_set_value(&connector->base, property, value);
|
2012-05-15 21:09:02 +00:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2012-05-15 21:09:05 +00:00
|
|
|
static int drm_mode_crtc_set_obj_prop(struct drm_mode_object *obj,
|
|
|
|
|
struct drm_property *property,
|
|
|
|
|
uint64_t value)
|
|
|
|
|
{
|
|
|
|
|
int ret = -EINVAL;
|
|
|
|
|
struct drm_crtc *crtc = obj_to_crtc(obj);
|
|
|
|
|
|
|
|
|
|
if (crtc->funcs->set_property)
|
|
|
|
|
ret = crtc->funcs->set_property(crtc, property, value);
|
|
|
|
|
if (!ret)
|
|
|
|
|
drm_object_property_set_value(obj, property, value);
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2012-05-17 08:23:27 +00:00
|
|
|
static int drm_mode_plane_set_obj_prop(struct drm_mode_object *obj,
|
|
|
|
|
struct drm_property *property,
|
|
|
|
|
uint64_t value)
|
|
|
|
|
{
|
|
|
|
|
int ret = -EINVAL;
|
|
|
|
|
struct drm_plane *plane = obj_to_plane(obj);
|
|
|
|
|
|
|
|
|
|
if (plane->funcs->set_property)
|
|
|
|
|
ret = plane->funcs->set_property(plane, property, value);
|
|
|
|
|
if (!ret)
|
|
|
|
|
drm_object_property_set_value(obj, property, value);
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2014-03-10 20:33:02 +00:00
|
|
|
/**
|
|
|
|
|
* drm_mode_getproperty_ioctl - get the current value of a object's property
|
|
|
|
|
* @dev: DRM device
|
|
|
|
|
* @data: ioctl data
|
|
|
|
|
* @file_priv: DRM file info
|
|
|
|
|
*
|
|
|
|
|
* This function retrieves the current value for an object's property. Compared
|
|
|
|
|
* to the connector specific ioctl this one is extended to also work on crtc and
|
|
|
|
|
* plane objects.
|
|
|
|
|
*
|
|
|
|
|
* Called by the user via ioctl.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* Zero on success, errno on failure.
|
|
|
|
|
*/
|
2012-05-15 21:09:02 +00:00
|
|
|
int drm_mode_obj_get_properties_ioctl(struct drm_device *dev, void *data,
|
|
|
|
|
struct drm_file *file_priv)
|
|
|
|
|
{
|
|
|
|
|
struct drm_mode_obj_get_properties *arg = data;
|
|
|
|
|
struct drm_mode_object *obj;
|
|
|
|
|
int ret = 0;
|
|
|
|
|
int i;
|
|
|
|
|
int copied = 0;
|
|
|
|
|
int props_count = 0;
|
|
|
|
|
uint32_t __user *props_ptr;
|
|
|
|
|
uint64_t __user *prop_values_ptr;
|
|
|
|
|
|
|
|
|
|
if (!drm_core_check_feature(dev, DRIVER_MODESET))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2012-12-01 23:28:11 +00:00
|
|
|
drm_modeset_lock_all(dev);
|
2012-05-15 21:09:02 +00:00
|
|
|
|
|
|
|
|
obj = drm_mode_object_find(dev, arg->obj_id, arg->obj_type);
|
|
|
|
|
if (!obj) {
|
2013-10-17 10:35:00 +00:00
|
|
|
ret = -ENOENT;
|
2012-05-15 21:09:02 +00:00
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
if (!obj->properties) {
|
|
|
|
|
ret = -EINVAL;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
2012-05-15 21:09:04 +00:00
|
|
|
props_count = obj->properties->count;
|
2012-05-15 21:09:02 +00:00
|
|
|
|
|
|
|
|
/* This ioctl is called twice, once to determine how much space is
|
|
|
|
|
* needed, and the 2nd time to fill it. */
|
|
|
|
|
if ((arg->count_props >= props_count) && props_count) {
|
|
|
|
|
copied = 0;
|
|
|
|
|
props_ptr = (uint32_t __user *)(unsigned long)(arg->props_ptr);
|
|
|
|
|
prop_values_ptr = (uint64_t __user *)(unsigned long)
|
|
|
|
|
(arg->prop_values_ptr);
|
|
|
|
|
for (i = 0; i < props_count; i++) {
|
|
|
|
|
if (put_user(obj->properties->ids[i],
|
|
|
|
|
props_ptr + copied)) {
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
if (put_user(obj->properties->values[i],
|
|
|
|
|
prop_values_ptr + copied)) {
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
copied++;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
arg->count_props = props_count;
|
|
|
|
|
out:
|
2012-12-01 23:28:11 +00:00
|
|
|
drm_modeset_unlock_all(dev);
|
2012-05-15 21:09:02 +00:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2014-03-10 20:33:02 +00:00
|
|
|
/**
|
|
|
|
|
* drm_mode_obj_set_property_ioctl - set the current value of an object's property
|
|
|
|
|
* @dev: DRM device
|
|
|
|
|
* @data: ioctl data
|
|
|
|
|
* @file_priv: DRM file info
|
|
|
|
|
*
|
|
|
|
|
* This function sets the current value for an object's property. It also calls
|
|
|
|
|
* into a driver's ->set_property callback to update the hardware state.
|
|
|
|
|
* Compared to the connector specific ioctl this one is extended to also work on
|
|
|
|
|
* crtc and plane objects.
|
|
|
|
|
*
|
|
|
|
|
* Called by the user via ioctl.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* Zero on success, errno on failure.
|
|
|
|
|
*/
|
2012-05-15 21:09:02 +00:00
|
|
|
int drm_mode_obj_set_property_ioctl(struct drm_device *dev, void *data,
|
|
|
|
|
struct drm_file *file_priv)
|
|
|
|
|
{
|
|
|
|
|
struct drm_mode_obj_set_property *arg = data;
|
|
|
|
|
struct drm_mode_object *arg_obj;
|
|
|
|
|
struct drm_mode_object *prop_obj;
|
|
|
|
|
struct drm_property *property;
|
|
|
|
|
int ret = -EINVAL;
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
if (!drm_core_check_feature(dev, DRIVER_MODESET))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2012-12-01 23:28:11 +00:00
|
|
|
drm_modeset_lock_all(dev);
|
2012-05-15 21:09:02 +00:00
|
|
|
|
|
|
|
|
arg_obj = drm_mode_object_find(dev, arg->obj_id, arg->obj_type);
|
2013-10-17 10:35:00 +00:00
|
|
|
if (!arg_obj) {
|
|
|
|
|
ret = -ENOENT;
|
2012-05-15 21:09:02 +00:00
|
|
|
goto out;
|
2013-10-17 10:35:00 +00:00
|
|
|
}
|
2012-05-15 21:09:02 +00:00
|
|
|
if (!arg_obj->properties)
|
|
|
|
|
goto out;
|
|
|
|
|
|
2012-05-15 21:09:04 +00:00
|
|
|
for (i = 0; i < arg_obj->properties->count; i++)
|
2012-05-15 21:09:02 +00:00
|
|
|
if (arg_obj->properties->ids[i] == arg->prop_id)
|
|
|
|
|
break;
|
|
|
|
|
|
2012-05-15 21:09:04 +00:00
|
|
|
if (i == arg_obj->properties->count)
|
2012-05-15 21:09:02 +00:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
|
|
prop_obj = drm_mode_object_find(dev, arg->prop_id,
|
|
|
|
|
DRM_MODE_OBJECT_PROPERTY);
|
2013-10-17 10:35:00 +00:00
|
|
|
if (!prop_obj) {
|
|
|
|
|
ret = -ENOENT;
|
2012-05-15 21:09:02 +00:00
|
|
|
goto out;
|
2013-10-17 10:35:00 +00:00
|
|
|
}
|
2012-05-15 21:09:02 +00:00
|
|
|
property = obj_to_property(prop_obj);
|
|
|
|
|
|
|
|
|
|
if (!drm_property_change_is_valid(property, arg->value))
|
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
|
|
switch (arg_obj->type) {
|
|
|
|
|
case DRM_MODE_OBJECT_CONNECTOR:
|
|
|
|
|
ret = drm_mode_connector_set_obj_prop(arg_obj, property,
|
|
|
|
|
arg->value);
|
|
|
|
|
break;
|
2012-05-15 21:09:05 +00:00
|
|
|
case DRM_MODE_OBJECT_CRTC:
|
|
|
|
|
ret = drm_mode_crtc_set_obj_prop(arg_obj, property, arg->value);
|
|
|
|
|
break;
|
2012-05-17 08:23:27 +00:00
|
|
|
case DRM_MODE_OBJECT_PLANE:
|
|
|
|
|
ret = drm_mode_plane_set_obj_prop(arg_obj, property, arg->value);
|
|
|
|
|
break;
|
2012-05-15 21:09:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
out:
|
2012-12-01 23:28:11 +00:00
|
|
|
drm_modeset_unlock_all(dev);
|
2012-05-15 21:09:02 +00:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2014-03-10 20:33:02 +00:00
|
|
|
/**
|
|
|
|
|
* drm_mode_connector_attach_encoder - attach a connector to an encoder
|
|
|
|
|
* @connector: connector to attach
|
|
|
|
|
* @encoder: encoder to attach @connector to
|
|
|
|
|
*
|
|
|
|
|
* This function links up a connector to an encoder. Note that the routing
|
|
|
|
|
* restrictions between encoders and crtcs are exposed to userspace through the
|
|
|
|
|
* possible_clones and possible_crtcs bitmasks.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* Zero on success, errno on failure.
|
|
|
|
|
*/
|
2008-11-07 22:05:41 +00:00
|
|
|
int drm_mode_connector_attach_encoder(struct drm_connector *connector,
|
|
|
|
|
struct drm_encoder *encoder)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
|
|
|
|
|
if (connector->encoder_ids[i] == 0) {
|
|
|
|
|
connector->encoder_ids[i] = encoder->base.id;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(drm_mode_connector_attach_encoder);
|
|
|
|
|
|
2014-03-10 20:33:02 +00:00
|
|
|
/**
|
|
|
|
|
* drm_mode_crtc_set_gamma_size - set the gamma table size
|
|
|
|
|
* @crtc: CRTC to set the gamma table size for
|
|
|
|
|
* @gamma_size: size of the gamma table
|
|
|
|
|
*
|
|
|
|
|
* Drivers which support gamma tables should set this to the supported gamma
|
|
|
|
|
* table size when initializing the CRTC. Currently the drm core only supports a
|
|
|
|
|
* fixed gamma table size.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* Zero on success, errno on failure.
|
|
|
|
|
*/
|
2012-02-01 10:38:23 +00:00
|
|
|
int drm_mode_crtc_set_gamma_size(struct drm_crtc *crtc,
|
2014-03-10 20:33:02 +00:00
|
|
|
int gamma_size)
|
2008-11-07 22:05:41 +00:00
|
|
|
{
|
|
|
|
|
crtc->gamma_size = gamma_size;
|
|
|
|
|
|
|
|
|
|
crtc->gamma_store = kzalloc(gamma_size * sizeof(uint16_t) * 3, GFP_KERNEL);
|
|
|
|
|
if (!crtc->gamma_store) {
|
|
|
|
|
crtc->gamma_size = 0;
|
2012-02-01 10:38:23 +00:00
|
|
|
return -ENOMEM;
|
2008-11-07 22:05:41 +00:00
|
|
|
}
|
|
|
|
|
|
2012-02-01 10:38:23 +00:00
|
|
|
return 0;
|
2008-11-07 22:05:41 +00:00
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(drm_mode_crtc_set_gamma_size);
|
|
|
|
|
|
2014-03-10 20:33:02 +00:00
|
|
|
/**
|
|
|
|
|
* drm_mode_gamma_set_ioctl - set the gamma table
|
|
|
|
|
* @dev: DRM device
|
|
|
|
|
* @data: ioctl data
|
|
|
|
|
* @file_priv: DRM file info
|
|
|
|
|
*
|
|
|
|
|
* Set the gamma table of a CRTC to the one passed in by the user. Userspace can
|
|
|
|
|
* inquire the required gamma table size through drm_mode_gamma_get_ioctl.
|
|
|
|
|
*
|
|
|
|
|
* Called by the user via ioctl.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* Zero on success, errno on failure.
|
|
|
|
|
*/
|
2008-11-07 22:05:41 +00:00
|
|
|
int drm_mode_gamma_set_ioctl(struct drm_device *dev,
|
|
|
|
|
void *data, struct drm_file *file_priv)
|
|
|
|
|
{
|
|
|
|
|
struct drm_mode_crtc_lut *crtc_lut = data;
|
|
|
|
|
struct drm_crtc *crtc;
|
|
|
|
|
void *r_base, *g_base, *b_base;
|
|
|
|
|
int size;
|
|
|
|
|
int ret = 0;
|
|
|
|
|
|
2011-02-08 03:55:21 +00:00
|
|
|
if (!drm_core_check_feature(dev, DRIVER_MODESET))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2012-12-01 23:28:11 +00:00
|
|
|
drm_modeset_lock_all(dev);
|
2013-10-05 20:36:52 +00:00
|
|
|
crtc = drm_crtc_find(dev, crtc_lut->crtc_id);
|
|
|
|
|
if (!crtc) {
|
2013-10-17 10:35:00 +00:00
|
|
|
ret = -ENOENT;
|
2008-11-07 22:05:41 +00:00
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
2012-05-17 11:27:24 +00:00
|
|
|
if (crtc->funcs->gamma_set == NULL) {
|
|
|
|
|
ret = -ENOSYS;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
2008-11-07 22:05:41 +00:00
|
|
|
/* memcpy into gamma store */
|
|
|
|
|
if (crtc_lut->gamma_size != crtc->gamma_size) {
|
|
|
|
|
ret = -EINVAL;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
size = crtc_lut->gamma_size * (sizeof(uint16_t));
|
|
|
|
|
r_base = crtc->gamma_store;
|
|
|
|
|
if (copy_from_user(r_base, (void __user *)(unsigned long)crtc_lut->red, size)) {
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
g_base = r_base + size;
|
|
|
|
|
if (copy_from_user(g_base, (void __user *)(unsigned long)crtc_lut->green, size)) {
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
b_base = g_base + size;
|
|
|
|
|
if (copy_from_user(b_base, (void __user *)(unsigned long)crtc_lut->blue, size)) {
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
2010-08-03 00:33:19 +00:00
|
|
|
crtc->funcs->gamma_set(crtc, r_base, g_base, b_base, 0, crtc->gamma_size);
|
2008-11-07 22:05:41 +00:00
|
|
|
|
|
|
|
|
out:
|
2012-12-01 23:28:11 +00:00
|
|
|
drm_modeset_unlock_all(dev);
|
2008-11-07 22:05:41 +00:00
|
|
|
return ret;
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
2014-03-10 20:33:02 +00:00
|
|
|
/**
|
|
|
|
|
* drm_mode_gamma_get_ioctl - get the gamma table
|
|
|
|
|
* @dev: DRM device
|
|
|
|
|
* @data: ioctl data
|
|
|
|
|
* @file_priv: DRM file info
|
|
|
|
|
*
|
|
|
|
|
* Copy the current gamma table into the storage provided. This also provides
|
|
|
|
|
* the gamma table size the driver expects, which can be used to size the
|
|
|
|
|
* allocated storage.
|
|
|
|
|
*
|
|
|
|
|
* Called by the user via ioctl.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* Zero on success, errno on failure.
|
|
|
|
|
*/
|
2008-11-07 22:05:41 +00:00
|
|
|
int drm_mode_gamma_get_ioctl(struct drm_device *dev,
|
|
|
|
|
void *data, struct drm_file *file_priv)
|
|
|
|
|
{
|
|
|
|
|
struct drm_mode_crtc_lut *crtc_lut = data;
|
|
|
|
|
struct drm_crtc *crtc;
|
|
|
|
|
void *r_base, *g_base, *b_base;
|
|
|
|
|
int size;
|
|
|
|
|
int ret = 0;
|
|
|
|
|
|
2011-02-08 03:55:21 +00:00
|
|
|
if (!drm_core_check_feature(dev, DRIVER_MODESET))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2012-12-01 23:28:11 +00:00
|
|
|
drm_modeset_lock_all(dev);
|
2013-10-05 20:36:52 +00:00
|
|
|
crtc = drm_crtc_find(dev, crtc_lut->crtc_id);
|
|
|
|
|
if (!crtc) {
|
2013-10-17 10:35:00 +00:00
|
|
|
ret = -ENOENT;
|
2008-11-07 22:05:41 +00:00
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* memcpy into gamma store */
|
|
|
|
|
if (crtc_lut->gamma_size != crtc->gamma_size) {
|
|
|
|
|
ret = -EINVAL;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
size = crtc_lut->gamma_size * (sizeof(uint16_t));
|
|
|
|
|
r_base = crtc->gamma_store;
|
|
|
|
|
if (copy_to_user((void __user *)(unsigned long)crtc_lut->red, r_base, size)) {
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
g_base = r_base + size;
|
|
|
|
|
if (copy_to_user((void __user *)(unsigned long)crtc_lut->green, g_base, size)) {
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
b_base = g_base + size;
|
|
|
|
|
if (copy_to_user((void __user *)(unsigned long)crtc_lut->blue, b_base, size)) {
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
out:
|
2012-12-01 23:28:11 +00:00
|
|
|
drm_modeset_unlock_all(dev);
|
2008-11-07 22:05:41 +00:00
|
|
|
return ret;
|
|
|
|
|
}
|
2009-11-17 17:43:55 +00:00
|
|
|
|
2014-03-10 20:33:02 +00:00
|
|
|
/**
|
|
|
|
|
* drm_mode_page_flip_ioctl - schedule an asynchronous fb update
|
|
|
|
|
* @dev: DRM device
|
|
|
|
|
* @data: ioctl data
|
|
|
|
|
* @file_priv: DRM file info
|
|
|
|
|
*
|
|
|
|
|
* This schedules an asynchronous update on a given CRTC, called page flip.
|
|
|
|
|
* Optionally a drm event is generated to signal the completion of the event.
|
|
|
|
|
* Generic drivers cannot assume that a pageflip with changed framebuffer
|
|
|
|
|
* properties (including driver specific metadata like tiling layout) will work,
|
|
|
|
|
* but some drivers support e.g. pixel format changes through the pageflip
|
|
|
|
|
* ioctl.
|
|
|
|
|
*
|
|
|
|
|
* Called by the user via ioctl.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* Zero on success, errno on failure.
|
|
|
|
|
*/
|
2009-11-17 17:43:55 +00:00
|
|
|
int drm_mode_page_flip_ioctl(struct drm_device *dev,
|
|
|
|
|
void *data, struct drm_file *file_priv)
|
|
|
|
|
{
|
|
|
|
|
struct drm_mode_crtc_page_flip *page_flip = data;
|
|
|
|
|
struct drm_crtc *crtc;
|
2012-12-11 00:07:12 +00:00
|
|
|
struct drm_framebuffer *fb = NULL, *old_fb = NULL;
|
2009-11-17 17:43:55 +00:00
|
|
|
struct drm_pending_vblank_event *e = NULL;
|
|
|
|
|
unsigned long flags;
|
|
|
|
|
int ret = -EINVAL;
|
|
|
|
|
|
|
|
|
|
if (page_flip->flags & ~DRM_MODE_PAGE_FLIP_FLAGS ||
|
|
|
|
|
page_flip->reserved != 0)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2013-07-23 01:50:00 +00:00
|
|
|
if ((page_flip->flags & DRM_MODE_PAGE_FLIP_ASYNC) && !dev->mode_config.async_page_flip)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2013-10-05 20:36:52 +00:00
|
|
|
crtc = drm_crtc_find(dev, page_flip->crtc_id);
|
|
|
|
|
if (!crtc)
|
2013-10-17 10:35:00 +00:00
|
|
|
return -ENOENT;
|
2009-11-17 17:43:55 +00:00
|
|
|
|
2013-11-19 17:10:12 +00:00
|
|
|
drm_modeset_lock(&crtc->mutex, NULL);
|
2014-04-01 22:22:40 +00:00
|
|
|
if (crtc->primary->fb == NULL) {
|
2010-07-17 19:23:26 +00:00
|
|
|
/* The framebuffer is currently unbound, presumably
|
|
|
|
|
* due to a hotplug event, that userspace has not
|
|
|
|
|
* yet discovered.
|
|
|
|
|
*/
|
|
|
|
|
ret = -EBUSY;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
2009-11-17 17:43:55 +00:00
|
|
|
if (crtc->funcs->page_flip == NULL)
|
|
|
|
|
goto out;
|
|
|
|
|
|
2012-12-02 20:53:40 +00:00
|
|
|
fb = drm_framebuffer_lookup(dev, page_flip->fb_id);
|
2013-10-17 10:35:01 +00:00
|
|
|
if (!fb) {
|
|
|
|
|
ret = -ENOENT;
|
2009-11-17 17:43:55 +00:00
|
|
|
goto out;
|
2013-10-17 10:35:01 +00:00
|
|
|
}
|
2009-11-17 17:43:55 +00:00
|
|
|
|
2013-09-25 15:45:30 +00:00
|
|
|
ret = drm_crtc_check_viewport(crtc, crtc->x, crtc->y, &crtc->mode, fb);
|
|
|
|
|
if (ret)
|
2012-03-13 10:35:45 +00:00
|
|
|
goto out;
|
|
|
|
|
|
2014-04-01 22:22:40 +00:00
|
|
|
if (crtc->primary->fb->pixel_format != fb->pixel_format) {
|
2013-04-21 23:38:46 +00:00
|
|
|
DRM_DEBUG_KMS("Page flip is not allowed to change frame buffer format.\n");
|
|
|
|
|
ret = -EINVAL;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
2009-11-17 17:43:55 +00:00
|
|
|
if (page_flip->flags & DRM_MODE_PAGE_FLIP_EVENT) {
|
|
|
|
|
ret = -ENOMEM;
|
|
|
|
|
spin_lock_irqsave(&dev->event_lock, flags);
|
|
|
|
|
if (file_priv->event_space < sizeof e->event) {
|
|
|
|
|
spin_unlock_irqrestore(&dev->event_lock, flags);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
file_priv->event_space -= sizeof e->event;
|
|
|
|
|
spin_unlock_irqrestore(&dev->event_lock, flags);
|
|
|
|
|
|
|
|
|
|
e = kzalloc(sizeof *e, GFP_KERNEL);
|
|
|
|
|
if (e == NULL) {
|
|
|
|
|
spin_lock_irqsave(&dev->event_lock, flags);
|
|
|
|
|
file_priv->event_space += sizeof e->event;
|
|
|
|
|
spin_unlock_irqrestore(&dev->event_lock, flags);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
2009-11-19 18:50:22 +00:00
|
|
|
e->event.base.type = DRM_EVENT_FLIP_COMPLETE;
|
2009-11-17 17:43:55 +00:00
|
|
|
e->event.base.length = sizeof e->event;
|
|
|
|
|
e->event.user_data = page_flip->user_data;
|
|
|
|
|
e->base.event = &e->event.base;
|
|
|
|
|
e->base.file_priv = file_priv;
|
|
|
|
|
e->base.destroy =
|
|
|
|
|
(void (*) (struct drm_pending_event *)) kfree;
|
|
|
|
|
}
|
|
|
|
|
|
2014-04-01 22:22:40 +00:00
|
|
|
old_fb = crtc->primary->fb;
|
2013-07-23 01:49:58 +00:00
|
|
|
ret = crtc->funcs->page_flip(crtc, fb, e, page_flip->flags);
|
2009-11-17 17:43:55 +00:00
|
|
|
if (ret) {
|
2012-04-18 04:47:02 +00:00
|
|
|
if (page_flip->flags & DRM_MODE_PAGE_FLIP_EVENT) {
|
|
|
|
|
spin_lock_irqsave(&dev->event_lock, flags);
|
|
|
|
|
file_priv->event_space += sizeof e->event;
|
|
|
|
|
spin_unlock_irqrestore(&dev->event_lock, flags);
|
|
|
|
|
kfree(e);
|
|
|
|
|
}
|
2012-12-11 00:07:12 +00:00
|
|
|
/* Keep the old fb, don't unref it. */
|
|
|
|
|
old_fb = NULL;
|
|
|
|
|
} else {
|
2013-02-13 15:08:33 +00:00
|
|
|
/*
|
|
|
|
|
* Warn if the driver hasn't properly updated the crtc->fb
|
|
|
|
|
* field to reflect that the new framebuffer is now used.
|
|
|
|
|
* Failing to do so will screw with the reference counting
|
|
|
|
|
* on framebuffers.
|
|
|
|
|
*/
|
2014-04-01 22:22:40 +00:00
|
|
|
WARN_ON(crtc->primary->fb != fb);
|
2012-12-11 00:07:12 +00:00
|
|
|
/* Unref only the old framebuffer. */
|
|
|
|
|
fb = NULL;
|
2009-11-17 17:43:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
out:
|
2012-12-11 00:07:12 +00:00
|
|
|
if (fb)
|
|
|
|
|
drm_framebuffer_unreference(fb);
|
|
|
|
|
if (old_fb)
|
|
|
|
|
drm_framebuffer_unreference(old_fb);
|
2013-11-19 17:10:12 +00:00
|
|
|
drm_modeset_unlock(&crtc->mutex);
|
drm: only grab the crtc lock for pageflips
The pagelip ioctl itself is rather simply, so the hard work for this
patch is auditing all the drivers:
- exynos: Pageflip is protect with dev->struct_mutex and ...
synchronous. But nothing fancy going on, besides a check whether the
crtc is enabled, which should probably be somewhere in the drm core
so that we have unified behaviour across all drivers.
- i915: hw-state is protected with dev->struct_mutex, the delayed
unpin work together with the other stuff the pageflip complete irq
handler needs is protected by the event_lock spinlock.
- nouveau: With the pin/unpin functions fixed, everything looks safe:
A bit of ttm wrestling and refcounting, and a few channel accesses.
The later are either already proteced sufficiently, or are now safe
with the channel locking introduced to make cursor updates safe.
- radeon: The irq_get/put functions look a bit race, since the
atomic_inc/dec isn't protect with locks. Otoh they're all per-crtc,
so we should be safe with per-crtc locking from the drm core. Then
there's tons of per-crtc register access, which could potentially go
through the indirect reg acces. But that's fixed to make cursor
updates concurrent. Bookeeping for the drm even is also protected
with the even_lock, which also protects against the pageflip irq
handler since radeon hw seems to have no way to queue these up
asynchronously. Otherwise just a bit of ttm-based buffer handling
and fencing, which is now safe with the previous patch to hold
bdev->fence_lock while grabbing the ttm fence.
- shmob: Only one crtc. That's an easy one ...
- vmwgfx: As usual a bit special with tons different things:
- Flippable check using is_implicit and num_implicit. Changes to
those seem to be nicely covered with the global modeset lock, so
we should be fine.
- Some dirty cliprect handling stuff, or at least that is my guess.
Looks like it's fine since either it's per-crtc, invariant or
(like the execbuf stuff launched) protected otherwise.
- Adding the actual flip to the fence_event list. On a quick look
this seems to have solid locking in place, too.
... but generally this is all way over my head.
- imx: Impressive display of races between the page_flip
implementation and the irq handler. Also, ipu_drm_set_base which
gets eventually called from the irq handler to update the display
base isn't really protected against concurrent set_config calls from
process context. In any case, going for per-crtc locking won't make
this worse, so nothing to do.
- omap: The new async callback code merged into 3.8 seems to have
solid locking in place, and there doesn't seem to be any shared
state at risk. Especially since the callbacks still use
modeset_lock_all and are so not converted.
v2: Update omapdrm analysis to 3.8 code per the discussion with Rob
Clark.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-11 15:59:31 +00:00
|
|
|
|
2009-11-17 17:43:55 +00:00
|
|
|
return ret;
|
|
|
|
|
}
|
2011-01-24 15:11:08 +00:00
|
|
|
|
2014-03-10 20:33:02 +00:00
|
|
|
/**
|
|
|
|
|
* drm_mode_config_reset - call ->reset callbacks
|
|
|
|
|
* @dev: drm device
|
|
|
|
|
*
|
|
|
|
|
* This functions calls all the crtc's, encoder's and connector's ->reset
|
|
|
|
|
* callback. Drivers can use this in e.g. their driver load or resume code to
|
|
|
|
|
* reset hardware and software state.
|
|
|
|
|
*/
|
2011-01-24 15:11:08 +00:00
|
|
|
void drm_mode_config_reset(struct drm_device *dev)
|
|
|
|
|
{
|
|
|
|
|
struct drm_crtc *crtc;
|
|
|
|
|
struct drm_encoder *encoder;
|
|
|
|
|
struct drm_connector *connector;
|
|
|
|
|
|
|
|
|
|
list_for_each_entry(crtc, &dev->mode_config.crtc_list, head)
|
|
|
|
|
if (crtc->funcs->reset)
|
|
|
|
|
crtc->funcs->reset(crtc);
|
|
|
|
|
|
|
|
|
|
list_for_each_entry(encoder, &dev->mode_config.encoder_list, head)
|
|
|
|
|
if (encoder->funcs->reset)
|
|
|
|
|
encoder->funcs->reset(encoder);
|
|
|
|
|
|
2012-10-23 18:23:35 +00:00
|
|
|
list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
|
|
|
|
|
connector->status = connector_status_unknown;
|
|
|
|
|
|
2011-01-24 15:11:08 +00:00
|
|
|
if (connector->funcs->reset)
|
|
|
|
|
connector->funcs->reset(connector);
|
2012-10-23 18:23:35 +00:00
|
|
|
}
|
2011-01-24 15:11:08 +00:00
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(drm_mode_config_reset);
|
2011-02-07 02:16:14 +00:00
|
|
|
|
2014-03-10 20:33:02 +00:00
|
|
|
/**
|
|
|
|
|
* drm_mode_create_dumb_ioctl - create a dumb backing storage buffer
|
|
|
|
|
* @dev: DRM device
|
|
|
|
|
* @data: ioctl data
|
|
|
|
|
* @file_priv: DRM file info
|
|
|
|
|
*
|
|
|
|
|
* This creates a new dumb buffer in the driver's backing storage manager (GEM,
|
|
|
|
|
* TTM or something else entirely) and returns the resulting buffer handle. This
|
|
|
|
|
* handle can then be wrapped up into a framebuffer modeset object.
|
|
|
|
|
*
|
|
|
|
|
* Note that userspace is not allowed to use such objects for render
|
|
|
|
|
* acceleration - drivers must create their own private ioctls for such a use
|
|
|
|
|
* case.
|
|
|
|
|
*
|
|
|
|
|
* Called by the user via ioctl.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* Zero on success, errno on failure.
|
|
|
|
|
*/
|
2011-02-07 02:16:14 +00:00
|
|
|
int drm_mode_create_dumb_ioctl(struct drm_device *dev,
|
|
|
|
|
void *data, struct drm_file *file_priv)
|
|
|
|
|
{
|
|
|
|
|
struct drm_mode_create_dumb *args = data;
|
2014-01-20 19:09:55 +00:00
|
|
|
u32 cpp, stride, size;
|
2011-02-07 02:16:14 +00:00
|
|
|
|
|
|
|
|
if (!dev->driver->dumb_create)
|
|
|
|
|
return -ENOSYS;
|
2014-01-20 19:09:55 +00:00
|
|
|
if (!args->width || !args->height || !args->bpp)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
/* overflow checks for 32bit size calculations */
|
|
|
|
|
cpp = DIV_ROUND_UP(args->bpp, 8);
|
|
|
|
|
if (cpp > 0xffffffffU / args->width)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
stride = cpp * args->width;
|
|
|
|
|
if (args->height > 0xffffffffU / stride)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
/* test for wrap-around */
|
|
|
|
|
size = args->height * stride;
|
|
|
|
|
if (PAGE_ALIGN(size) == 0)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2011-02-07 02:16:14 +00:00
|
|
|
return dev->driver->dumb_create(file_priv, dev, args);
|
|
|
|
|
}
|
|
|
|
|
|
2014-03-10 20:33:02 +00:00
|
|
|
/**
|
|
|
|
|
* drm_mode_mmap_dumb_ioctl - create an mmap offset for a dumb backing storage buffer
|
|
|
|
|
* @dev: DRM device
|
|
|
|
|
* @data: ioctl data
|
|
|
|
|
* @file_priv: DRM file info
|
|
|
|
|
*
|
|
|
|
|
* Allocate an offset in the drm device node's address space to be able to
|
|
|
|
|
* memory map a dumb buffer.
|
|
|
|
|
*
|
|
|
|
|
* Called by the user via ioctl.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* Zero on success, errno on failure.
|
|
|
|
|
*/
|
2011-02-07 02:16:14 +00:00
|
|
|
int drm_mode_mmap_dumb_ioctl(struct drm_device *dev,
|
|
|
|
|
void *data, struct drm_file *file_priv)
|
|
|
|
|
{
|
|
|
|
|
struct drm_mode_map_dumb *args = data;
|
|
|
|
|
|
|
|
|
|
/* call driver ioctl to get mmap offset */
|
|
|
|
|
if (!dev->driver->dumb_map_offset)
|
|
|
|
|
return -ENOSYS;
|
|
|
|
|
|
|
|
|
|
return dev->driver->dumb_map_offset(file_priv, dev, args->handle, &args->offset);
|
|
|
|
|
}
|
|
|
|
|
|
2014-03-10 20:33:02 +00:00
|
|
|
/**
|
|
|
|
|
* drm_mode_destroy_dumb_ioctl - destroy a dumb backing strage buffer
|
|
|
|
|
* @dev: DRM device
|
|
|
|
|
* @data: ioctl data
|
|
|
|
|
* @file_priv: DRM file info
|
|
|
|
|
*
|
|
|
|
|
* This destroys the userspace handle for the given dumb backing storage buffer.
|
|
|
|
|
* Since buffer objects must be reference counted in the kernel a buffer object
|
|
|
|
|
* won't be immediately freed if a framebuffer modeset object still uses it.
|
|
|
|
|
*
|
|
|
|
|
* Called by the user via ioctl.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* Zero on success, errno on failure.
|
|
|
|
|
*/
|
2011-02-07 02:16:14 +00:00
|
|
|
int drm_mode_destroy_dumb_ioctl(struct drm_device *dev,
|
|
|
|
|
void *data, struct drm_file *file_priv)
|
|
|
|
|
{
|
|
|
|
|
struct drm_mode_destroy_dumb *args = data;
|
|
|
|
|
|
|
|
|
|
if (!dev->driver->dumb_destroy)
|
|
|
|
|
return -ENOSYS;
|
|
|
|
|
|
|
|
|
|
return dev->driver->dumb_destroy(file_priv, dev, args->handle);
|
|
|
|
|
}
|
2011-11-29 20:02:54 +00:00
|
|
|
|
2014-03-10 20:33:02 +00:00
|
|
|
/**
|
|
|
|
|
* drm_fb_get_bpp_depth - get the bpp/depth values for format
|
|
|
|
|
* @format: pixel format (DRM_FORMAT_*)
|
|
|
|
|
* @depth: storage for the depth value
|
|
|
|
|
* @bpp: storage for the bpp value
|
|
|
|
|
*
|
|
|
|
|
* This only supports RGB formats here for compat with code that doesn't use
|
|
|
|
|
* pixel formats directly yet.
|
2011-11-29 20:02:54 +00:00
|
|
|
*/
|
|
|
|
|
void drm_fb_get_bpp_depth(uint32_t format, unsigned int *depth,
|
|
|
|
|
int *bpp)
|
|
|
|
|
{
|
|
|
|
|
switch (format) {
|
2013-01-31 17:43:37 +00:00
|
|
|
case DRM_FORMAT_C8:
|
2011-11-17 16:05:13 +00:00
|
|
|
case DRM_FORMAT_RGB332:
|
|
|
|
|
case DRM_FORMAT_BGR233:
|
2011-11-29 20:02:54 +00:00
|
|
|
*depth = 8;
|
|
|
|
|
*bpp = 8;
|
|
|
|
|
break;
|
2011-11-17 16:05:13 +00:00
|
|
|
case DRM_FORMAT_XRGB1555:
|
|
|
|
|
case DRM_FORMAT_XBGR1555:
|
|
|
|
|
case DRM_FORMAT_RGBX5551:
|
|
|
|
|
case DRM_FORMAT_BGRX5551:
|
|
|
|
|
case DRM_FORMAT_ARGB1555:
|
|
|
|
|
case DRM_FORMAT_ABGR1555:
|
|
|
|
|
case DRM_FORMAT_RGBA5551:
|
|
|
|
|
case DRM_FORMAT_BGRA5551:
|
2011-11-29 20:02:54 +00:00
|
|
|
*depth = 15;
|
|
|
|
|
*bpp = 16;
|
|
|
|
|
break;
|
2011-11-17 16:05:13 +00:00
|
|
|
case DRM_FORMAT_RGB565:
|
|
|
|
|
case DRM_FORMAT_BGR565:
|
2011-11-29 20:02:54 +00:00
|
|
|
*depth = 16;
|
|
|
|
|
*bpp = 16;
|
|
|
|
|
break;
|
2011-11-17 16:05:13 +00:00
|
|
|
case DRM_FORMAT_RGB888:
|
|
|
|
|
case DRM_FORMAT_BGR888:
|
|
|
|
|
*depth = 24;
|
|
|
|
|
*bpp = 24;
|
|
|
|
|
break;
|
|
|
|
|
case DRM_FORMAT_XRGB8888:
|
|
|
|
|
case DRM_FORMAT_XBGR8888:
|
|
|
|
|
case DRM_FORMAT_RGBX8888:
|
|
|
|
|
case DRM_FORMAT_BGRX8888:
|
2011-11-29 20:02:54 +00:00
|
|
|
*depth = 24;
|
|
|
|
|
*bpp = 32;
|
|
|
|
|
break;
|
2011-11-17 16:05:13 +00:00
|
|
|
case DRM_FORMAT_XRGB2101010:
|
|
|
|
|
case DRM_FORMAT_XBGR2101010:
|
|
|
|
|
case DRM_FORMAT_RGBX1010102:
|
|
|
|
|
case DRM_FORMAT_BGRX1010102:
|
|
|
|
|
case DRM_FORMAT_ARGB2101010:
|
|
|
|
|
case DRM_FORMAT_ABGR2101010:
|
|
|
|
|
case DRM_FORMAT_RGBA1010102:
|
|
|
|
|
case DRM_FORMAT_BGRA1010102:
|
2011-11-29 20:02:54 +00:00
|
|
|
*depth = 30;
|
|
|
|
|
*bpp = 32;
|
|
|
|
|
break;
|
2011-11-17 16:05:13 +00:00
|
|
|
case DRM_FORMAT_ARGB8888:
|
|
|
|
|
case DRM_FORMAT_ABGR8888:
|
|
|
|
|
case DRM_FORMAT_RGBA8888:
|
|
|
|
|
case DRM_FORMAT_BGRA8888:
|
2011-11-29 20:02:54 +00:00
|
|
|
*depth = 32;
|
|
|
|
|
*bpp = 32;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
2013-10-15 18:06:51 +00:00
|
|
|
DRM_DEBUG_KMS("unsupported pixel format %s\n",
|
|
|
|
|
drm_get_format_name(format));
|
2011-11-29 20:02:54 +00:00
|
|
|
*depth = 0;
|
|
|
|
|
*bpp = 0;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(drm_fb_get_bpp_depth);
|
2012-04-05 18:35:15 +00:00
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* drm_format_num_planes - get the number of planes for format
|
|
|
|
|
* @format: pixel format (DRM_FORMAT_*)
|
|
|
|
|
*
|
2014-03-10 20:33:02 +00:00
|
|
|
* Returns:
|
2012-04-05 18:35:15 +00:00
|
|
|
* The number of planes used by the specified pixel format.
|
|
|
|
|
*/
|
|
|
|
|
int drm_format_num_planes(uint32_t format)
|
|
|
|
|
{
|
|
|
|
|
switch (format) {
|
|
|
|
|
case DRM_FORMAT_YUV410:
|
|
|
|
|
case DRM_FORMAT_YVU410:
|
|
|
|
|
case DRM_FORMAT_YUV411:
|
|
|
|
|
case DRM_FORMAT_YVU411:
|
|
|
|
|
case DRM_FORMAT_YUV420:
|
|
|
|
|
case DRM_FORMAT_YVU420:
|
|
|
|
|
case DRM_FORMAT_YUV422:
|
|
|
|
|
case DRM_FORMAT_YVU422:
|
|
|
|
|
case DRM_FORMAT_YUV444:
|
|
|
|
|
case DRM_FORMAT_YVU444:
|
|
|
|
|
return 3;
|
|
|
|
|
case DRM_FORMAT_NV12:
|
|
|
|
|
case DRM_FORMAT_NV21:
|
|
|
|
|
case DRM_FORMAT_NV16:
|
|
|
|
|
case DRM_FORMAT_NV61:
|
2012-05-18 21:47:40 +00:00
|
|
|
case DRM_FORMAT_NV24:
|
|
|
|
|
case DRM_FORMAT_NV42:
|
2012-04-05 18:35:15 +00:00
|
|
|
return 2;
|
|
|
|
|
default:
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(drm_format_num_planes);
|
2012-04-05 18:35:16 +00:00
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* drm_format_plane_cpp - determine the bytes per pixel value
|
|
|
|
|
* @format: pixel format (DRM_FORMAT_*)
|
|
|
|
|
* @plane: plane index
|
|
|
|
|
*
|
2014-03-10 20:33:02 +00:00
|
|
|
* Returns:
|
2012-04-05 18:35:16 +00:00
|
|
|
* The bytes per pixel value for the specified plane.
|
|
|
|
|
*/
|
|
|
|
|
int drm_format_plane_cpp(uint32_t format, int plane)
|
|
|
|
|
{
|
|
|
|
|
unsigned int depth;
|
|
|
|
|
int bpp;
|
|
|
|
|
|
|
|
|
|
if (plane >= drm_format_num_planes(format))
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
switch (format) {
|
|
|
|
|
case DRM_FORMAT_YUYV:
|
|
|
|
|
case DRM_FORMAT_YVYU:
|
|
|
|
|
case DRM_FORMAT_UYVY:
|
|
|
|
|
case DRM_FORMAT_VYUY:
|
|
|
|
|
return 2;
|
|
|
|
|
case DRM_FORMAT_NV12:
|
|
|
|
|
case DRM_FORMAT_NV21:
|
|
|
|
|
case DRM_FORMAT_NV16:
|
|
|
|
|
case DRM_FORMAT_NV61:
|
2012-05-18 21:47:40 +00:00
|
|
|
case DRM_FORMAT_NV24:
|
|
|
|
|
case DRM_FORMAT_NV42:
|
2012-04-05 18:35:16 +00:00
|
|
|
return plane ? 2 : 1;
|
|
|
|
|
case DRM_FORMAT_YUV410:
|
|
|
|
|
case DRM_FORMAT_YVU410:
|
|
|
|
|
case DRM_FORMAT_YUV411:
|
|
|
|
|
case DRM_FORMAT_YVU411:
|
|
|
|
|
case DRM_FORMAT_YUV420:
|
|
|
|
|
case DRM_FORMAT_YVU420:
|
|
|
|
|
case DRM_FORMAT_YUV422:
|
|
|
|
|
case DRM_FORMAT_YVU422:
|
|
|
|
|
case DRM_FORMAT_YUV444:
|
|
|
|
|
case DRM_FORMAT_YVU444:
|
|
|
|
|
return 1;
|
|
|
|
|
default:
|
|
|
|
|
drm_fb_get_bpp_depth(format, &depth, &bpp);
|
|
|
|
|
return bpp >> 3;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(drm_format_plane_cpp);
|
2012-04-05 18:35:17 +00:00
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* drm_format_horz_chroma_subsampling - get the horizontal chroma subsampling factor
|
|
|
|
|
* @format: pixel format (DRM_FORMAT_*)
|
|
|
|
|
*
|
2014-03-10 20:33:02 +00:00
|
|
|
* Returns:
|
2012-04-05 18:35:17 +00:00
|
|
|
* The horizontal chroma subsampling factor for the
|
|
|
|
|
* specified pixel format.
|
|
|
|
|
*/
|
|
|
|
|
int drm_format_horz_chroma_subsampling(uint32_t format)
|
|
|
|
|
{
|
|
|
|
|
switch (format) {
|
|
|
|
|
case DRM_FORMAT_YUV411:
|
|
|
|
|
case DRM_FORMAT_YVU411:
|
|
|
|
|
case DRM_FORMAT_YUV410:
|
|
|
|
|
case DRM_FORMAT_YVU410:
|
|
|
|
|
return 4;
|
|
|
|
|
case DRM_FORMAT_YUYV:
|
|
|
|
|
case DRM_FORMAT_YVYU:
|
|
|
|
|
case DRM_FORMAT_UYVY:
|
|
|
|
|
case DRM_FORMAT_VYUY:
|
|
|
|
|
case DRM_FORMAT_NV12:
|
|
|
|
|
case DRM_FORMAT_NV21:
|
|
|
|
|
case DRM_FORMAT_NV16:
|
|
|
|
|
case DRM_FORMAT_NV61:
|
|
|
|
|
case DRM_FORMAT_YUV422:
|
|
|
|
|
case DRM_FORMAT_YVU422:
|
|
|
|
|
case DRM_FORMAT_YUV420:
|
|
|
|
|
case DRM_FORMAT_YVU420:
|
|
|
|
|
return 2;
|
|
|
|
|
default:
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(drm_format_horz_chroma_subsampling);
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* drm_format_vert_chroma_subsampling - get the vertical chroma subsampling factor
|
|
|
|
|
* @format: pixel format (DRM_FORMAT_*)
|
|
|
|
|
*
|
2014-03-10 20:33:02 +00:00
|
|
|
* Returns:
|
2012-04-05 18:35:17 +00:00
|
|
|
* The vertical chroma subsampling factor for the
|
|
|
|
|
* specified pixel format.
|
|
|
|
|
*/
|
|
|
|
|
int drm_format_vert_chroma_subsampling(uint32_t format)
|
|
|
|
|
{
|
|
|
|
|
switch (format) {
|
|
|
|
|
case DRM_FORMAT_YUV410:
|
|
|
|
|
case DRM_FORMAT_YVU410:
|
|
|
|
|
return 4;
|
|
|
|
|
case DRM_FORMAT_YUV420:
|
|
|
|
|
case DRM_FORMAT_YVU420:
|
|
|
|
|
case DRM_FORMAT_NV12:
|
|
|
|
|
case DRM_FORMAT_NV21:
|
|
|
|
|
return 2;
|
|
|
|
|
default:
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(drm_format_vert_chroma_subsampling);
|
2013-04-15 13:37:16 +00:00
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* drm_mode_config_init - initialize DRM mode_configuration structure
|
|
|
|
|
* @dev: DRM device
|
|
|
|
|
*
|
|
|
|
|
* Initialize @dev's mode_config structure, used for tracking the graphics
|
|
|
|
|
* configuration of @dev.
|
|
|
|
|
*
|
|
|
|
|
* Since this initializes the modeset locks, no locking is possible. Which is no
|
|
|
|
|
* problem, since this should happen single threaded at init time. It is the
|
|
|
|
|
* driver's problem to ensure this guarantee.
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
void drm_mode_config_init(struct drm_device *dev)
|
|
|
|
|
{
|
|
|
|
|
mutex_init(&dev->mode_config.mutex);
|
2013-11-19 17:10:12 +00:00
|
|
|
drm_modeset_lock_init(&dev->mode_config.connection_mutex);
|
2013-04-15 13:37:16 +00:00
|
|
|
mutex_init(&dev->mode_config.idr_mutex);
|
|
|
|
|
mutex_init(&dev->mode_config.fb_lock);
|
|
|
|
|
INIT_LIST_HEAD(&dev->mode_config.fb_list);
|
|
|
|
|
INIT_LIST_HEAD(&dev->mode_config.crtc_list);
|
|
|
|
|
INIT_LIST_HEAD(&dev->mode_config.connector_list);
|
2013-08-14 20:47:37 +00:00
|
|
|
INIT_LIST_HEAD(&dev->mode_config.bridge_list);
|
2013-04-15 13:37:16 +00:00
|
|
|
INIT_LIST_HEAD(&dev->mode_config.encoder_list);
|
|
|
|
|
INIT_LIST_HEAD(&dev->mode_config.property_list);
|
|
|
|
|
INIT_LIST_HEAD(&dev->mode_config.property_blob_list);
|
|
|
|
|
INIT_LIST_HEAD(&dev->mode_config.plane_list);
|
|
|
|
|
idr_init(&dev->mode_config.crtc_idr);
|
|
|
|
|
|
|
|
|
|
drm_modeset_lock_all(dev);
|
|
|
|
|
drm_mode_create_standard_connector_properties(dev);
|
2014-04-02 00:16:57 +00:00
|
|
|
drm_mode_create_standard_plane_properties(dev);
|
2013-04-15 13:37:16 +00:00
|
|
|
drm_modeset_unlock_all(dev);
|
|
|
|
|
|
|
|
|
|
/* Just to be sure */
|
|
|
|
|
dev->mode_config.num_fb = 0;
|
|
|
|
|
dev->mode_config.num_connector = 0;
|
|
|
|
|
dev->mode_config.num_crtc = 0;
|
|
|
|
|
dev->mode_config.num_encoder = 0;
|
2014-04-01 22:22:30 +00:00
|
|
|
dev->mode_config.num_overlay_plane = 0;
|
|
|
|
|
dev->mode_config.num_total_plane = 0;
|
2013-04-15 13:37:16 +00:00
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(drm_mode_config_init);
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* drm_mode_config_cleanup - free up DRM mode_config info
|
|
|
|
|
* @dev: DRM device
|
|
|
|
|
*
|
|
|
|
|
* Free up all the connectors and CRTCs associated with this DRM device, then
|
|
|
|
|
* free up the framebuffers and associated buffer objects.
|
|
|
|
|
*
|
|
|
|
|
* Note that since this /should/ happen single-threaded at driver/device
|
|
|
|
|
* teardown time, no locking is required. It's the driver's job to ensure that
|
|
|
|
|
* this guarantee actually holds true.
|
|
|
|
|
*
|
|
|
|
|
* FIXME: cleanup any dangling user buffer objects too
|
|
|
|
|
*/
|
|
|
|
|
void drm_mode_config_cleanup(struct drm_device *dev)
|
|
|
|
|
{
|
|
|
|
|
struct drm_connector *connector, *ot;
|
|
|
|
|
struct drm_crtc *crtc, *ct;
|
|
|
|
|
struct drm_encoder *encoder, *enct;
|
2013-08-14 20:47:37 +00:00
|
|
|
struct drm_bridge *bridge, *brt;
|
2013-04-15 13:37:16 +00:00
|
|
|
struct drm_framebuffer *fb, *fbt;
|
|
|
|
|
struct drm_property *property, *pt;
|
|
|
|
|
struct drm_property_blob *blob, *bt;
|
|
|
|
|
struct drm_plane *plane, *plt;
|
|
|
|
|
|
|
|
|
|
list_for_each_entry_safe(encoder, enct, &dev->mode_config.encoder_list,
|
|
|
|
|
head) {
|
|
|
|
|
encoder->funcs->destroy(encoder);
|
|
|
|
|
}
|
|
|
|
|
|
2013-08-14 20:47:37 +00:00
|
|
|
list_for_each_entry_safe(bridge, brt,
|
|
|
|
|
&dev->mode_config.bridge_list, head) {
|
|
|
|
|
bridge->funcs->destroy(bridge);
|
|
|
|
|
}
|
|
|
|
|
|
2013-04-15 13:37:16 +00:00
|
|
|
list_for_each_entry_safe(connector, ot,
|
|
|
|
|
&dev->mode_config.connector_list, head) {
|
|
|
|
|
connector->funcs->destroy(connector);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
list_for_each_entry_safe(property, pt, &dev->mode_config.property_list,
|
|
|
|
|
head) {
|
|
|
|
|
drm_property_destroy(dev, property);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
list_for_each_entry_safe(blob, bt, &dev->mode_config.property_blob_list,
|
|
|
|
|
head) {
|
|
|
|
|
drm_property_destroy_blob(dev, blob);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Single-threaded teardown context, so it's not required to grab the
|
|
|
|
|
* fb_lock to protect against concurrent fb_list access. Contrary, it
|
|
|
|
|
* would actually deadlock with the drm_framebuffer_cleanup function.
|
|
|
|
|
*
|
|
|
|
|
* Also, if there are any framebuffers left, that's a driver leak now,
|
|
|
|
|
* so politely WARN about this.
|
|
|
|
|
*/
|
|
|
|
|
WARN_ON(!list_empty(&dev->mode_config.fb_list));
|
|
|
|
|
list_for_each_entry_safe(fb, fbt, &dev->mode_config.fb_list, head) {
|
|
|
|
|
drm_framebuffer_remove(fb);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
list_for_each_entry_safe(plane, plt, &dev->mode_config.plane_list,
|
|
|
|
|
head) {
|
|
|
|
|
plane->funcs->destroy(plane);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
list_for_each_entry_safe(crtc, ct, &dev->mode_config.crtc_list, head) {
|
|
|
|
|
crtc->funcs->destroy(crtc);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
idr_destroy(&dev->mode_config.crtc_idr);
|
2013-11-19 17:10:12 +00:00
|
|
|
drm_modeset_lock_fini(&dev->mode_config.connection_mutex);
|
2013-04-15 13:37:16 +00:00
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(drm_mode_config_cleanup);
|
