2008-11-08 05:05:41 +07: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 15:15:10 +07:00
|
|
|
#include <linux/ctype.h>
|
2008-11-08 05:05:41 +07: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 15:04:11 +07:00
|
|
|
#include <linux/slab.h>
|
2011-08-31 05:16:33 +07:00
|
|
|
#include <linux/export.h>
|
2016-11-15 21:37:08 +07:00
|
|
|
#include <linux/dma-fence.h>
|
2012-10-03 00:01:07 +07:00
|
|
|
#include <drm/drmP.h>
|
|
|
|
#include <drm/drm_crtc.h>
|
|
|
|
#include <drm/drm_edid.h>
|
|
|
|
#include <drm/drm_fourcc.h>
|
2013-11-20 00:10:12 +07:00
|
|
|
#include <drm/drm_modeset_lock.h>
|
2014-12-19 04:01:50 +07:00
|
|
|
#include <drm/drm_atomic.h>
|
2016-06-21 15:54:22 +07:00
|
|
|
#include <drm/drm_auth.h>
|
2016-10-06 22:21:06 +07:00
|
|
|
#include <drm/drm_debugfs_crc.h>
|
2008-11-08 05:05:41 +07:00
|
|
|
|
2014-01-23 21:35:24 +07:00
|
|
|
#include "drm_crtc_internal.h"
|
2014-09-10 17:43:53 +07:00
|
|
|
#include "drm_internal.h"
|
2014-01-23 21:35:24 +07:00
|
|
|
|
2017-01-25 13:26:57 +07:00
|
|
|
/**
|
|
|
|
* DOC: overview
|
|
|
|
*
|
|
|
|
* A CRTC represents the overall display pipeline. It receives pixel data from
|
|
|
|
* &drm_plane and blends them together. The &drm_display_mode is also attached
|
|
|
|
* to the CRTC, specifying display timings. On the output side the data is fed
|
|
|
|
* to one or more &drm_encoder, which are then each connected to one
|
|
|
|
* &drm_connector.
|
|
|
|
*
|
|
|
|
* To create a CRTC, a KMS drivers allocates and zeroes an instances of
|
|
|
|
* &struct drm_crtc (possibly as part of a larger structure) and registers it
|
|
|
|
* with a call to drm_crtc_init_with_planes().
|
|
|
|
*
|
|
|
|
* The CRTC is also the entry point for legacy modeset operations, see
|
|
|
|
* &drm_crtc_funcs.set_config, legacy plane operations, see
|
|
|
|
* &drm_crtc_funcs.page_flip and &drm_crtc_funcs.cursor_set2, and other legacy
|
|
|
|
* operations like &drm_crtc_funcs.gamma_set. For atomic drivers all these
|
|
|
|
* features are controlled through &drm_property and
|
|
|
|
* &drm_mode_config_funcs.atomic_check and &drm_mode_config_funcs.atomic_check.
|
|
|
|
*/
|
|
|
|
|
2016-12-29 19:41:28 +07:00
|
|
|
/**
|
|
|
|
* drm_crtc_from_index - find the registered CRTC at an index
|
|
|
|
* @dev: DRM device
|
|
|
|
* @idx: index of registered CRTC to find for
|
|
|
|
*
|
|
|
|
* Given a CRTC index, return the registered CRTC from DRM device's
|
2017-01-07 15:52:11 +07:00
|
|
|
* list of CRTCs with matching index. This is the inverse of drm_crtc_index().
|
|
|
|
* It's useful in the vblank callbacks (like &drm_driver.enable_vblank or
|
|
|
|
* &drm_driver.disable_vblank), since that still deals with indices instead
|
|
|
|
* of pointers to &struct drm_crtc."
|
2016-12-29 19:41:28 +07:00
|
|
|
*/
|
|
|
|
struct drm_crtc *drm_crtc_from_index(struct drm_device *dev, int idx)
|
|
|
|
{
|
|
|
|
struct drm_crtc *crtc;
|
|
|
|
|
|
|
|
drm_for_each_crtc(crtc, dev)
|
|
|
|
if (idx == crtc->index)
|
|
|
|
return crtc;
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_crtc_from_index);
|
|
|
|
|
2016-06-08 23:47:27 +07:00
|
|
|
/**
|
|
|
|
* drm_crtc_force_disable - Forcibly turn off a CRTC
|
|
|
|
* @crtc: CRTC to turn off
|
|
|
|
*
|
2017-03-21 23:41:49 +07:00
|
|
|
* Note: This should only be used by non-atomic legacy drivers.
|
|
|
|
*
|
2016-06-08 23:47:27 +07:00
|
|
|
* Returns:
|
|
|
|
* Zero on success, error code on failure.
|
|
|
|
*/
|
|
|
|
int drm_crtc_force_disable(struct drm_crtc *crtc)
|
|
|
|
{
|
|
|
|
struct drm_mode_set set = {
|
|
|
|
.crtc = crtc,
|
|
|
|
};
|
|
|
|
|
2017-03-21 23:41:49 +07:00
|
|
|
WARN_ON(drm_drv_uses_atomic_modeset(crtc->dev));
|
|
|
|
|
2016-06-08 23:47:27 +07:00
|
|
|
return drm_mode_set_config_internal(&set);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_crtc_force_disable);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_crtc_force_disable_all - Forcibly turn off all enabled CRTCs
|
|
|
|
* @dev: DRM device whose CRTCs to turn off
|
|
|
|
*
|
|
|
|
* Drivers may want to call this on unload to ensure that all displays are
|
|
|
|
* unlit and the GPU is in a consistent, low power state. Takes modeset locks.
|
|
|
|
*
|
2017-03-21 23:41:49 +07:00
|
|
|
* Note: This should only be used by non-atomic legacy drivers. For an atomic
|
|
|
|
* version look at drm_atomic_helper_shutdown().
|
|
|
|
*
|
2016-06-08 23:47:27 +07:00
|
|
|
* Returns:
|
|
|
|
* Zero on success, error code on failure.
|
|
|
|
*/
|
|
|
|
int drm_crtc_force_disable_all(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
struct drm_crtc *crtc;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
drm_modeset_lock_all(dev);
|
|
|
|
drm_for_each_crtc(crtc, dev)
|
|
|
|
if (crtc->enabled) {
|
|
|
|
ret = drm_crtc_force_disable(crtc);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
drm_modeset_unlock_all(dev);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_crtc_force_disable_all);
|
|
|
|
|
2015-12-08 23:41:53 +07:00
|
|
|
static unsigned int drm_num_crtcs(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
unsigned int num = 0;
|
|
|
|
struct drm_crtc *tmp;
|
|
|
|
|
|
|
|
drm_for_each_crtc(tmp, dev) {
|
|
|
|
num++;
|
|
|
|
}
|
|
|
|
|
|
|
|
return num;
|
|
|
|
}
|
|
|
|
|
2016-11-14 18:58:23 +07:00
|
|
|
int drm_crtc_register_all(struct drm_device *dev)
|
2016-06-21 21:37:09 +07:00
|
|
|
{
|
|
|
|
struct drm_crtc *crtc;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
drm_for_each_crtc(crtc, dev) {
|
2016-10-06 22:21:06 +07:00
|
|
|
if (drm_debugfs_crtc_add(crtc))
|
|
|
|
DRM_ERROR("Failed to initialize debugfs entry for CRTC '%s'.\n",
|
|
|
|
crtc->name);
|
|
|
|
|
2016-06-21 21:37:09 +07:00
|
|
|
if (crtc->funcs->late_register)
|
|
|
|
ret = crtc->funcs->late_register(crtc);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-11-14 18:58:23 +07:00
|
|
|
void drm_crtc_unregister_all(struct drm_device *dev)
|
2016-06-21 21:37:09 +07:00
|
|
|
{
|
|
|
|
struct drm_crtc *crtc;
|
|
|
|
|
|
|
|
drm_for_each_crtc(crtc, dev) {
|
|
|
|
if (crtc->funcs->early_unregister)
|
|
|
|
crtc->funcs->early_unregister(crtc);
|
2016-10-06 22:21:06 +07:00
|
|
|
drm_debugfs_crtc_remove(crtc);
|
2016-06-21 21:37:09 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-06 22:21:06 +07:00
|
|
|
static int drm_crtc_crc_init(struct drm_crtc *crtc)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_DEBUG_FS
|
|
|
|
spin_lock_init(&crtc->crc.lock);
|
|
|
|
init_waitqueue_head(&crtc->crc.wq);
|
|
|
|
crtc->crc.source = kstrdup("auto", GFP_KERNEL);
|
|
|
|
if (!crtc->crc.source)
|
|
|
|
return -ENOMEM;
|
|
|
|
#endif
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void drm_crtc_crc_fini(struct drm_crtc *crtc)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_DEBUG_FS
|
|
|
|
kfree(crtc->crc.source);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2016-12-07 00:47:17 +07:00
|
|
|
static const struct dma_fence_ops drm_crtc_fence_ops;
|
|
|
|
|
2016-11-15 21:37:08 +07:00
|
|
|
static struct drm_crtc *fence_to_crtc(struct dma_fence *fence)
|
|
|
|
{
|
|
|
|
BUG_ON(fence->ops != &drm_crtc_fence_ops);
|
|
|
|
return container_of(fence->lock, struct drm_crtc, fence_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const char *drm_crtc_fence_get_driver_name(struct dma_fence *fence)
|
|
|
|
{
|
|
|
|
struct drm_crtc *crtc = fence_to_crtc(fence);
|
|
|
|
|
|
|
|
return crtc->dev->driver->name;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const char *drm_crtc_fence_get_timeline_name(struct dma_fence *fence)
|
|
|
|
{
|
|
|
|
struct drm_crtc *crtc = fence_to_crtc(fence);
|
|
|
|
|
|
|
|
return crtc->timeline_name;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool drm_crtc_fence_enable_signaling(struct dma_fence *fence)
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2016-12-07 00:47:17 +07:00
|
|
|
static const struct dma_fence_ops drm_crtc_fence_ops = {
|
2016-11-15 21:37:08 +07:00
|
|
|
.get_driver_name = drm_crtc_fence_get_driver_name,
|
|
|
|
.get_timeline_name = drm_crtc_fence_get_timeline_name,
|
|
|
|
.enable_signaling = drm_crtc_fence_enable_signaling,
|
|
|
|
.wait = dma_fence_default_wait,
|
|
|
|
};
|
|
|
|
|
2016-12-07 00:47:17 +07:00
|
|
|
struct dma_fence *drm_crtc_create_fence(struct drm_crtc *crtc)
|
|
|
|
{
|
|
|
|
struct dma_fence *fence;
|
|
|
|
|
|
|
|
fence = kzalloc(sizeof(*fence), GFP_KERNEL);
|
|
|
|
if (!fence)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
dma_fence_init(fence, &drm_crtc_fence_ops, &crtc->fence_lock,
|
|
|
|
crtc->fence_context, ++crtc->fence_seqno);
|
|
|
|
|
|
|
|
return fence;
|
|
|
|
}
|
|
|
|
|
2008-11-08 05:05:41 +07:00
|
|
|
/**
|
2014-04-02 05:22:38 +07:00
|
|
|
* drm_crtc_init_with_planes - Initialise a new CRTC object with
|
|
|
|
* specified primary and cursor planes.
|
2008-11-08 05:05:41 +07:00
|
|
|
* @dev: DRM device
|
|
|
|
* @crtc: CRTC object to init
|
2014-04-02 05:22:38 +07:00
|
|
|
* @primary: Primary plane for CRTC
|
|
|
|
* @cursor: Cursor plane for CRTC
|
2008-11-08 05:05:41 +07:00
|
|
|
* @funcs: callbacks for the new CRTC
|
drm: Pass 'name' to drm_crtc_init_with_planes()
Done with coccinelle for the most part. However, it thinks '...' is
part of the semantic patch, so I put an 'int DOTDOTDOT' placeholder
in its place and got rid of it with sed afterwards.
I didn't convert drm_crtc_init() since passing the varargs through
would mean either cpp macros or va_list, and I figured we don't
care about these legacy functions enough to warrant the extra pain.
@@
identifier dev, crtc, primary, cursor, funcs;
@@
int drm_crtc_init_with_planes(struct drm_device *dev,
struct drm_crtc *crtc,
struct drm_plane *primary, struct drm_plane *cursor,
const struct drm_crtc_funcs *funcs
+ ,const char *name, int DOTDOTDOT
)
{ ... }
@@
identifier dev, crtc, primary, cursor, funcs;
@@
int drm_crtc_init_with_planes(struct drm_device *dev,
struct drm_crtc *crtc,
struct drm_plane *primary, struct drm_plane *cursor,
const struct drm_crtc_funcs *funcs
+ ,const char *name, int DOTDOTDOT
);
@@
expression E1, E2, E3, E4, E5;
@@
drm_crtc_init_with_planes(E1, E2, E3, E4, E5
+ ,NULL
)
v2: Split crtc and plane changes apart
Pass NULL for no-name instead of ""
Leave drm_crtc_init() alone
v3: Add ', or NULL...' to @name kernel doc (Jani)
Annotate the function with __printf() attribute (Jani)
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Link: http://patchwork.freedesktop.org/patch/msgid/1449670771-2751-1-git-send-email-ville.syrjala@linux.intel.com
2015-12-09 21:19:31 +07:00
|
|
|
* @name: printf style format string for the CRTC name, or NULL for default name
|
2008-11-08 05:05:41 +07:00
|
|
|
*
|
2016-09-21 15:59:25 +07:00
|
|
|
* Inits a new object created as base part of a driver crtc object. Drivers
|
|
|
|
* should use this function instead of drm_crtc_init(), which is only provided
|
|
|
|
* for backwards compatibility with drivers which do not yet support universal
|
|
|
|
* planes). For really simple hardware which has only 1 plane look at
|
|
|
|
* drm_simple_display_pipe_init() instead.
|
2012-03-13 17:35:48 +07:00
|
|
|
*
|
2014-03-11 03:33:02 +07:00
|
|
|
* Returns:
|
2012-03-13 17:35:48 +07:00
|
|
|
* Zero on success, error code on failure.
|
2008-11-08 05:05:41 +07:00
|
|
|
*/
|
2014-04-02 05:22:38 +07:00
|
|
|
int drm_crtc_init_with_planes(struct drm_device *dev, struct drm_crtc *crtc,
|
|
|
|
struct drm_plane *primary,
|
2014-06-10 22:28:11 +07:00
|
|
|
struct drm_plane *cursor,
|
drm: Pass 'name' to drm_crtc_init_with_planes()
Done with coccinelle for the most part. However, it thinks '...' is
part of the semantic patch, so I put an 'int DOTDOTDOT' placeholder
in its place and got rid of it with sed afterwards.
I didn't convert drm_crtc_init() since passing the varargs through
would mean either cpp macros or va_list, and I figured we don't
care about these legacy functions enough to warrant the extra pain.
@@
identifier dev, crtc, primary, cursor, funcs;
@@
int drm_crtc_init_with_planes(struct drm_device *dev,
struct drm_crtc *crtc,
struct drm_plane *primary, struct drm_plane *cursor,
const struct drm_crtc_funcs *funcs
+ ,const char *name, int DOTDOTDOT
)
{ ... }
@@
identifier dev, crtc, primary, cursor, funcs;
@@
int drm_crtc_init_with_planes(struct drm_device *dev,
struct drm_crtc *crtc,
struct drm_plane *primary, struct drm_plane *cursor,
const struct drm_crtc_funcs *funcs
+ ,const char *name, int DOTDOTDOT
);
@@
expression E1, E2, E3, E4, E5;
@@
drm_crtc_init_with_planes(E1, E2, E3, E4, E5
+ ,NULL
)
v2: Split crtc and plane changes apart
Pass NULL for no-name instead of ""
Leave drm_crtc_init() alone
v3: Add ', or NULL...' to @name kernel doc (Jani)
Annotate the function with __printf() attribute (Jani)
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Link: http://patchwork.freedesktop.org/patch/msgid/1449670771-2751-1-git-send-email-ville.syrjala@linux.intel.com
2015-12-09 21:19:31 +07:00
|
|
|
const struct drm_crtc_funcs *funcs,
|
|
|
|
const char *name, ...)
|
2008-11-08 05:05:41 +07:00
|
|
|
{
|
2013-11-20 00:10:12 +07:00
|
|
|
struct drm_mode_config *config = &dev->mode_config;
|
2012-03-13 17:35:48 +07:00
|
|
|
int ret;
|
|
|
|
|
2015-03-17 18:05:29 +07:00
|
|
|
WARN_ON(primary && primary->type != DRM_PLANE_TYPE_PRIMARY);
|
|
|
|
WARN_ON(cursor && cursor->type != DRM_PLANE_TYPE_CURSOR);
|
|
|
|
|
2008-11-08 05:05:41 +07:00
|
|
|
crtc->dev = dev;
|
|
|
|
crtc->funcs = funcs;
|
|
|
|
|
2016-06-08 19:19:00 +07:00
|
|
|
INIT_LIST_HEAD(&crtc->commit_list);
|
|
|
|
spin_lock_init(&crtc->commit_lock);
|
|
|
|
|
2013-11-20 00:10:12 +07:00
|
|
|
drm_modeset_lock_init(&crtc->mutex);
|
2017-02-28 21:46:37 +07:00
|
|
|
ret = drm_mode_object_add(dev, &crtc->base, DRM_MODE_OBJECT_CRTC);
|
2012-03-13 17:35:48 +07:00
|
|
|
if (ret)
|
2014-11-12 17:59:47 +07:00
|
|
|
return ret;
|
2008-11-08 05:05:41 +07:00
|
|
|
|
2015-12-08 23:41:53 +07:00
|
|
|
if (name) {
|
|
|
|
va_list ap;
|
|
|
|
|
|
|
|
va_start(ap, name);
|
|
|
|
crtc->name = kvasprintf(GFP_KERNEL, name, ap);
|
|
|
|
va_end(ap);
|
|
|
|
} else {
|
|
|
|
crtc->name = kasprintf(GFP_KERNEL, "crtc-%d",
|
|
|
|
drm_num_crtcs(dev));
|
|
|
|
}
|
|
|
|
if (!crtc->name) {
|
2016-04-15 12:10:32 +07:00
|
|
|
drm_mode_object_unregister(dev, &crtc->base);
|
2015-12-08 23:41:53 +07:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2016-11-15 21:37:08 +07:00
|
|
|
crtc->fence_context = dma_fence_context_alloc(1);
|
|
|
|
spin_lock_init(&crtc->fence_lock);
|
|
|
|
snprintf(crtc->timeline_name, sizeof(crtc->timeline_name),
|
|
|
|
"CRTC:%d-%s", crtc->base.id, crtc->name);
|
|
|
|
|
2012-05-16 04:09:05 +07:00
|
|
|
crtc->base.properties = &crtc->properties;
|
|
|
|
|
2013-11-20 00:10:12 +07:00
|
|
|
list_add_tail(&crtc->head, &config->crtc_list);
|
2016-05-28 02:05:00 +07:00
|
|
|
crtc->index = config->num_crtc++;
|
2012-03-13 17:35:48 +07:00
|
|
|
|
2014-04-02 05:22:38 +07:00
|
|
|
crtc->primary = primary;
|
2014-06-10 22:28:11 +07:00
|
|
|
crtc->cursor = cursor;
|
2016-11-05 21:52:01 +07:00
|
|
|
if (primary && !primary->possible_crtcs)
|
2014-04-02 05:22:38 +07:00
|
|
|
primary->possible_crtcs = 1 << drm_crtc_index(crtc);
|
2016-11-05 21:52:01 +07:00
|
|
|
if (cursor && !cursor->possible_crtcs)
|
2014-06-10 22:28:11 +07:00
|
|
|
cursor->possible_crtcs = 1 << drm_crtc_index(crtc);
|
2014-04-02 05:22:38 +07:00
|
|
|
|
2016-10-06 22:21:06 +07:00
|
|
|
ret = drm_crtc_crc_init(crtc);
|
|
|
|
if (ret) {
|
|
|
|
drm_mode_object_unregister(dev, &crtc->base);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-01-22 22:36:21 +07:00
|
|
|
if (drm_core_check_feature(dev, DRIVER_ATOMIC)) {
|
|
|
|
drm_object_attach_property(&crtc->base, config->prop_active, 0);
|
2015-05-26 01:11:52 +07:00
|
|
|
drm_object_attach_property(&crtc->base, config->prop_mode_id, 0);
|
2016-11-16 20:00:21 +07:00
|
|
|
drm_object_attach_property(&crtc->base,
|
|
|
|
config->prop_out_fence_ptr, 0);
|
2015-01-22 22:36:21 +07:00
|
|
|
}
|
|
|
|
|
2014-11-12 17:59:47 +07:00
|
|
|
return 0;
|
2008-11-08 05:05:41 +07:00
|
|
|
}
|
2014-04-02 05:22:38 +07:00
|
|
|
EXPORT_SYMBOL(drm_crtc_init_with_planes);
|
2008-11-08 05:05:41 +07:00
|
|
|
|
|
|
|
/**
|
2013-06-05 19:39:55 +07:00
|
|
|
* drm_crtc_cleanup - Clean up the core crtc usage
|
2008-11-08 05:05:41 +07:00
|
|
|
* @crtc: CRTC to cleanup
|
|
|
|
*
|
2013-06-05 19:39:55 +07: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-08 05:05:41 +07:00
|
|
|
*/
|
|
|
|
void drm_crtc_cleanup(struct drm_crtc *crtc)
|
|
|
|
{
|
|
|
|
struct drm_device *dev = crtc->dev;
|
|
|
|
|
2016-05-28 02:05:00 +07:00
|
|
|
/* Note that the crtc_list is considered to be static; should we
|
|
|
|
* remove the drm_crtc at runtime we would have to decrement all
|
|
|
|
* the indices on the drm_crtc after us in the crtc_list.
|
|
|
|
*/
|
|
|
|
|
2016-10-06 22:21:06 +07:00
|
|
|
drm_crtc_crc_fini(crtc);
|
|
|
|
|
2012-11-19 16:44:56 +07:00
|
|
|
kfree(crtc->gamma_store);
|
|
|
|
crtc->gamma_store = NULL;
|
2008-11-08 05:05:41 +07:00
|
|
|
|
2013-11-20 00:10:12 +07:00
|
|
|
drm_modeset_lock_fini(&crtc->mutex);
|
|
|
|
|
2016-04-15 12:10:32 +07:00
|
|
|
drm_mode_object_unregister(dev, &crtc->base);
|
2008-11-08 05:05:41 +07:00
|
|
|
list_del(&crtc->head);
|
|
|
|
dev->mode_config.num_crtc--;
|
2014-11-25 18:09:49 +07:00
|
|
|
|
|
|
|
WARN_ON(crtc->state && !crtc->funcs->atomic_destroy_state);
|
|
|
|
if (crtc->state && crtc->funcs->atomic_destroy_state)
|
|
|
|
crtc->funcs->atomic_destroy_state(crtc, crtc->state);
|
2014-12-10 17:38:49 +07:00
|
|
|
|
2015-12-08 23:41:53 +07:00
|
|
|
kfree(crtc->name);
|
|
|
|
|
2014-12-10 17:38:49 +07:00
|
|
|
memset(crtc, 0, sizeof(*crtc));
|
2008-11-08 05:05:41 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_crtc_cleanup);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_mode_getcrtc - get CRTC configuration
|
2012-12-02 06:09:18 +07:00
|
|
|
* @dev: drm device for the ioctl
|
|
|
|
* @data: data pointer for the ioctl
|
|
|
|
* @file_priv: drm file for the ioctl call
|
2008-11-08 05:05:41 +07:00
|
|
|
*
|
|
|
|
* Construct a CRTC configuration structure to return to the user.
|
|
|
|
*
|
|
|
|
* Called by the user via ioctl.
|
|
|
|
*
|
2014-03-11 03:33:02 +07:00
|
|
|
* Returns:
|
2014-11-20 00:38:09 +07:00
|
|
|
* Zero on success, negative errno on failure.
|
2008-11-08 05:05:41 +07:00
|
|
|
*/
|
|
|
|
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;
|
|
|
|
|
2011-02-08 10:55:21 +07:00
|
|
|
if (!drm_core_check_feature(dev, DRIVER_MODESET))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2013-10-06 03:36:52 +07:00
|
|
|
crtc = drm_crtc_find(dev, crtc_resp->crtc_id);
|
2014-11-12 14:45:01 +07:00
|
|
|
if (!crtc)
|
|
|
|
return -ENOENT;
|
2008-11-08 05:05:41 +07:00
|
|
|
|
|
|
|
crtc_resp->gamma_size = crtc->gamma_size;
|
2016-12-14 01:19:12 +07:00
|
|
|
|
2017-03-28 14:01:45 +07:00
|
|
|
drm_modeset_lock(&crtc->primary->mutex, NULL);
|
2016-12-14 01:19:12 +07:00
|
|
|
if (crtc->primary->state && crtc->primary->state->fb)
|
|
|
|
crtc_resp->fb_id = crtc->primary->state->fb->base.id;
|
|
|
|
else if (!crtc->primary->state && crtc->primary->fb)
|
2014-04-02 05:22:40 +07:00
|
|
|
crtc_resp->fb_id = crtc->primary->fb->base.id;
|
2008-11-08 05:05:41 +07:00
|
|
|
else
|
|
|
|
crtc_resp->fb_id = 0;
|
|
|
|
|
2017-03-28 14:01:45 +07:00
|
|
|
if (crtc->primary->state) {
|
2015-02-22 18:24:17 +07:00
|
|
|
crtc_resp->x = crtc->primary->state->src_x >> 16;
|
|
|
|
crtc_resp->y = crtc->primary->state->src_y >> 16;
|
2017-03-28 14:01:45 +07:00
|
|
|
}
|
|
|
|
drm_modeset_unlock(&crtc->primary->mutex);
|
|
|
|
|
|
|
|
drm_modeset_lock(&crtc->mutex, NULL);
|
|
|
|
if (crtc->state) {
|
2015-02-22 18:24:17 +07:00
|
|
|
if (crtc->state->enable) {
|
2015-05-22 19:34:48 +07:00
|
|
|
drm_mode_convert_to_umode(&crtc_resp->mode, &crtc->state->mode);
|
2015-02-22 18:24:17 +07:00
|
|
|
crtc_resp->mode_valid = 1;
|
2008-11-08 05:05:41 +07:00
|
|
|
|
2015-02-22 18:24:17 +07:00
|
|
|
} else {
|
|
|
|
crtc_resp->mode_valid = 0;
|
|
|
|
}
|
2008-11-08 05:05:41 +07:00
|
|
|
} else {
|
2015-02-22 18:24:17 +07:00
|
|
|
crtc_resp->x = crtc->x;
|
|
|
|
crtc_resp->y = crtc->y;
|
|
|
|
if (crtc->enabled) {
|
2015-05-22 19:34:48 +07:00
|
|
|
drm_mode_convert_to_umode(&crtc_resp->mode, &crtc->mode);
|
2015-02-22 18:24:17 +07:00
|
|
|
crtc_resp->mode_valid = 1;
|
|
|
|
|
|
|
|
} else {
|
|
|
|
crtc_resp->mode_valid = 0;
|
|
|
|
}
|
2008-11-08 05:05:41 +07:00
|
|
|
}
|
2017-03-28 14:01:45 +07:00
|
|
|
drm_modeset_unlock(&crtc->mutex);
|
2008-11-08 05:05:41 +07:00
|
|
|
|
2014-11-12 17:59:47 +07:00
|
|
|
return 0;
|
2008-11-08 05:05:41 +07:00
|
|
|
}
|
|
|
|
|
2017-03-23 04:50:56 +07:00
|
|
|
static int __drm_mode_set_config_internal(struct drm_mode_set *set,
|
|
|
|
struct drm_modeset_acquire_ctx *ctx)
|
2012-12-11 19:47:23 +07:00
|
|
|
{
|
|
|
|
struct drm_crtc *crtc = set->crtc;
|
2013-06-15 05:13:16 +07:00
|
|
|
struct drm_framebuffer *fb;
|
|
|
|
struct drm_crtc *tmp;
|
2012-12-11 07:07:12 +07:00
|
|
|
int ret;
|
|
|
|
|
2013-06-15 05:13:16 +07: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 ...
|
|
|
|
*/
|
2015-07-10 04:44:35 +07:00
|
|
|
drm_for_each_crtc(tmp, crtc->dev)
|
2014-07-27 18:42:42 +07:00
|
|
|
tmp->primary->old_fb = tmp->primary->fb;
|
2013-06-15 05:13:16 +07:00
|
|
|
|
2012-12-11 07:07:12 +07:00
|
|
|
fb = set->fb;
|
2012-12-11 19:47:23 +07:00
|
|
|
|
2017-03-23 04:50:57 +07:00
|
|
|
ret = crtc->funcs->set_config(set, ctx);
|
2012-12-11 07:07:12 +07:00
|
|
|
if (ret == 0) {
|
2014-04-02 05:22:38 +07:00
|
|
|
crtc->primary->crtc = crtc;
|
2014-04-23 22:34:06 +07:00
|
|
|
crtc->primary->fb = fb;
|
2013-06-15 05:13:16 +07:00
|
|
|
}
|
2013-06-15 05:13:15 +07:00
|
|
|
|
2015-07-10 04:44:35 +07:00
|
|
|
drm_for_each_crtc(tmp, crtc->dev) {
|
2014-04-02 05:22:40 +07:00
|
|
|
if (tmp->primary->fb)
|
2017-02-28 21:46:40 +07:00
|
|
|
drm_framebuffer_get(tmp->primary->fb);
|
2014-07-27 18:42:42 +07:00
|
|
|
if (tmp->primary->old_fb)
|
2017-02-28 21:46:40 +07:00
|
|
|
drm_framebuffer_put(tmp->primary->old_fb);
|
2014-07-27 18:42:42 +07:00
|
|
|
tmp->primary->old_fb = NULL;
|
2012-12-11 07:07:12 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
2012-12-11 19:47:23 +07:00
|
|
|
}
|
2017-03-23 04:50:55 +07:00
|
|
|
/**
|
|
|
|
* drm_mode_set_config_internal - helper to call &drm_mode_config_funcs.set_config
|
|
|
|
* @set: modeset config to set
|
|
|
|
*
|
|
|
|
* This is a little helper to wrap internal calls to the
|
|
|
|
* &drm_mode_config_funcs.set_config driver interface. The only thing it adds is
|
|
|
|
* correct refcounting dance.
|
|
|
|
*
|
|
|
|
* This should only be used by non-atomic legacy drivers.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* Zero on success, negative errno on failure.
|
|
|
|
*/
|
|
|
|
int drm_mode_set_config_internal(struct drm_mode_set *set)
|
|
|
|
{
|
|
|
|
WARN_ON(drm_drv_uses_atomic_modeset(set->crtc->dev));
|
|
|
|
|
2017-03-23 04:50:56 +07:00
|
|
|
return __drm_mode_set_config_internal(set, NULL);
|
2017-03-23 04:50:55 +07:00
|
|
|
}
|
2012-12-11 19:47:23 +07:00
|
|
|
EXPORT_SYMBOL(drm_mode_set_config_internal);
|
|
|
|
|
2014-04-02 05:22:34 +07: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 22:45:30 +07:00
|
|
|
*/
|
2014-04-02 05:22:34 +07: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 22:45:30 +07:00
|
|
|
|
|
|
|
{
|
|
|
|
int hdisplay, vdisplay;
|
|
|
|
|
2017-01-25 13:26:56 +07:00
|
|
|
drm_mode_get_hv_timing(mode, &hdisplay, &vdisplay);
|
2013-09-25 22:45:31 +07:00
|
|
|
|
2015-10-16 22:38:39 +07:00
|
|
|
if (crtc->state &&
|
2016-09-26 23:30:46 +07:00
|
|
|
drm_rotation_90_or_270(crtc->primary->state->rotation))
|
2013-09-25 22:45:30 +07:00
|
|
|
swap(hdisplay, vdisplay);
|
|
|
|
|
2016-09-21 15:59:24 +07:00
|
|
|
return drm_framebuffer_check_src_coords(x << 16, y << 16,
|
|
|
|
hdisplay << 16, vdisplay << 16,
|
|
|
|
fb);
|
2013-09-25 22:45:30 +07:00
|
|
|
}
|
2014-04-02 05:22:34 +07:00
|
|
|
EXPORT_SYMBOL(drm_crtc_check_viewport);
|
2013-09-25 22:45:30 +07:00
|
|
|
|
2008-11-08 05:05:41 +07:00
|
|
|
/**
|
|
|
|
* drm_mode_setcrtc - set CRTC configuration
|
2012-12-02 06:09:18 +07:00
|
|
|
* @dev: drm device for the ioctl
|
|
|
|
* @data: data pointer for the ioctl
|
|
|
|
* @file_priv: drm file for the ioctl call
|
2008-11-08 05:05:41 +07:00
|
|
|
*
|
|
|
|
* Build a new CRTC configuration based on user request.
|
|
|
|
*
|
|
|
|
* Called by the user via ioctl.
|
|
|
|
*
|
2014-03-11 03:33:02 +07:00
|
|
|
* Returns:
|
2014-11-20 00:38:09 +07:00
|
|
|
* Zero on success, negative errno on failure.
|
2008-11-08 05:05:41 +07:00
|
|
|
*/
|
|
|
|
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 17:35:38 +07:00
|
|
|
struct drm_crtc *crtc;
|
2008-11-08 05:05:41 +07: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;
|
2017-03-23 04:50:56 +07:00
|
|
|
struct drm_modeset_acquire_ctx ctx;
|
2012-05-17 18:27:21 +07:00
|
|
|
int ret;
|
2008-11-08 05:05:41 +07:00
|
|
|
int i;
|
|
|
|
|
2011-02-08 10:55:21 +07:00
|
|
|
if (!drm_core_check_feature(dev, DRIVER_MODESET))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2015-07-07 16:08:35 +07:00
|
|
|
/*
|
|
|
|
* Universal plane src offsets are only 16.16, prevent havoc for
|
|
|
|
* drivers using universal plane code internally.
|
|
|
|
*/
|
|
|
|
if (crtc_req->x & 0xffff0000 || crtc_req->y & 0xffff0000)
|
2012-03-13 17:35:41 +07:00
|
|
|
return -ERANGE;
|
|
|
|
|
2013-10-06 03:36:52 +07:00
|
|
|
crtc = drm_crtc_find(dev, crtc_req->crtc_id);
|
|
|
|
if (!crtc) {
|
2009-07-20 12:48:07 +07:00
|
|
|
DRM_DEBUG_KMS("Unknown CRTC ID %d\n", crtc_req->crtc_id);
|
2017-03-23 04:50:56 +07:00
|
|
|
return -ENOENT;
|
2008-11-08 05:05:41 +07:00
|
|
|
}
|
2015-12-08 23:41:53 +07:00
|
|
|
DRM_DEBUG_KMS("[CRTC:%d:%s]\n", crtc->base.id, crtc->name);
|
2008-11-08 05:05:41 +07:00
|
|
|
|
2017-04-07 02:06:54 +07:00
|
|
|
mutex_lock(&crtc->dev->mode_config.mutex);
|
2017-03-23 04:50:56 +07:00
|
|
|
drm_modeset_acquire_init(&ctx, 0);
|
|
|
|
retry:
|
|
|
|
ret = drm_modeset_lock_all_ctx(crtc->dev, &ctx);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
2008-11-08 05:05:41 +07: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-02 05:22:40 +07:00
|
|
|
if (!crtc->primary->fb) {
|
2012-03-13 17:35:38 +07:00
|
|
|
DRM_DEBUG_KMS("CRTC doesn't have current FB\n");
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
2008-11-08 05:05:41 +07:00
|
|
|
}
|
2014-04-02 05:22:40 +07:00
|
|
|
fb = crtc->primary->fb;
|
2012-12-11 07:07:12 +07:00
|
|
|
/* Make refcounting symmetric with the lookup path. */
|
2017-02-28 21:46:40 +07:00
|
|
|
drm_framebuffer_get(fb);
|
2008-11-08 05:05:41 +07:00
|
|
|
} else {
|
2012-12-03 03:53:40 +07:00
|
|
|
fb = drm_framebuffer_lookup(dev, crtc_req->fb_id);
|
|
|
|
if (!fb) {
|
2009-07-20 12:48:07 +07:00
|
|
|
DRM_DEBUG_KMS("Unknown FB ID%d\n",
|
|
|
|
crtc_req->fb_id);
|
2013-10-17 17:35:01 +07:00
|
|
|
ret = -ENOENT;
|
2008-11-08 05:05:41 +07:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
mode = drm_mode_create(dev);
|
2012-03-13 17:35:43 +07:00
|
|
|
if (!mode) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2015-05-22 19:34:48 +07:00
|
|
|
ret = drm_mode_convert_umode(mode, &crtc_req->mode);
|
2012-03-13 17:35:44 +07:00
|
|
|
if (ret) {
|
|
|
|
DRM_DEBUG_KMS("Invalid mode\n");
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2015-03-09 15:41:07 +07:00
|
|
|
/*
|
|
|
|
* Check whether the primary plane supports the fb pixel format.
|
|
|
|
* Drivers not implementing the universal planes API use a
|
|
|
|
* default formats list provided by the DRM core which doesn't
|
|
|
|
* match real hardware capabilities. Skip the check in that
|
|
|
|
* case.
|
|
|
|
*/
|
|
|
|
if (!crtc->primary->format_default) {
|
|
|
|
ret = drm_plane_check_pixel_format(crtc->primary,
|
2016-12-15 04:32:55 +07:00
|
|
|
fb->format->format);
|
2015-03-09 15:41:07 +07:00
|
|
|
if (ret) {
|
2016-11-12 08:12:56 +07:00
|
|
|
struct drm_format_name_buf format_name;
|
|
|
|
DRM_DEBUG_KMS("Invalid pixel format %s\n",
|
2016-12-15 04:32:55 +07:00
|
|
|
drm_get_format_name(fb->format->format,
|
2016-11-12 08:12:56 +07:00
|
|
|
&format_name));
|
2015-03-09 15:41:07 +07:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-09-25 22:45:30 +07:00
|
|
|
ret = drm_crtc_check_viewport(crtc, crtc_req->x, crtc_req->y,
|
|
|
|
mode, fb);
|
|
|
|
if (ret)
|
2012-03-13 17:35:45 +07:00
|
|
|
goto out;
|
2013-09-25 22:45:30 +07:00
|
|
|
|
2008-11-08 05:05:41 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
if (crtc_req->count_connectors == 0 && mode) {
|
2009-07-20 12:48:07 +07:00
|
|
|
DRM_DEBUG_KMS("Count connectors is 0 but mode set\n");
|
2008-11-08 05:05:41 +07:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2009-08-03 19:43:58 +07:00
|
|
|
if (crtc_req->count_connectors > 0 && (!mode || !fb)) {
|
2009-07-20 12:48:07 +07:00
|
|
|
DRM_DEBUG_KMS("Count connectors is %d but no mode or fb set\n",
|
2008-11-08 05:05:41 +07: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;
|
|
|
|
}
|
|
|
|
|
2014-12-10 19:03:36 +07:00
|
|
|
connector_set = kmalloc_array(crtc_req->count_connectors,
|
|
|
|
sizeof(struct drm_connector *),
|
|
|
|
GFP_KERNEL);
|
2008-11-08 05:05:41 +07:00
|
|
|
if (!connector_set) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < crtc_req->count_connectors; i++) {
|
2016-04-27 08:10:09 +07:00
|
|
|
connector_set[i] = NULL;
|
2011-12-20 05:06:42 +07:00
|
|
|
set_connectors_ptr = (uint32_t __user *)(unsigned long)crtc_req->set_connectors_ptr;
|
2008-11-08 05:05:41 +07:00
|
|
|
if (get_user(out_id, &set_connectors_ptr[i])) {
|
|
|
|
ret = -EFAULT;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2016-04-27 08:10:09 +07:00
|
|
|
connector = drm_connector_lookup(dev, out_id);
|
2013-10-06 03:36:52 +07:00
|
|
|
if (!connector) {
|
2009-07-20 12:48:07 +07:00
|
|
|
DRM_DEBUG_KMS("Connector id %d unknown\n",
|
|
|
|
out_id);
|
2013-10-17 17:35:00 +07:00
|
|
|
ret = -ENOENT;
|
2008-11-08 05:05:41 +07:00
|
|
|
goto out;
|
|
|
|
}
|
2010-07-16 02:43:25 +07:00
|
|
|
DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n",
|
|
|
|
connector->base.id,
|
2014-06-03 18:56:20 +07:00
|
|
|
connector->name);
|
2008-11-08 05:05:41 +07: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 10:11:23 +07:00
|
|
|
set.fb = fb;
|
2017-03-23 04:50:56 +07:00
|
|
|
ret = __drm_mode_set_config_internal(&set, &ctx);
|
2008-11-08 05:05:41 +07:00
|
|
|
|
|
|
|
out:
|
2012-12-11 07:07:12 +07:00
|
|
|
if (fb)
|
2017-02-28 21:46:40 +07:00
|
|
|
drm_framebuffer_put(fb);
|
2012-12-11 07:07:12 +07:00
|
|
|
|
2016-04-27 08:10:09 +07:00
|
|
|
if (connector_set) {
|
|
|
|
for (i = 0; i < crtc_req->count_connectors; i++) {
|
|
|
|
if (connector_set[i])
|
2017-02-28 21:46:39 +07:00
|
|
|
drm_connector_put(connector_set[i]);
|
2016-04-27 08:10:09 +07:00
|
|
|
}
|
|
|
|
}
|
2008-11-08 05:05:41 +07:00
|
|
|
kfree(connector_set);
|
2012-03-13 17:35:43 +07:00
|
|
|
drm_mode_destroy(dev, mode);
|
2017-03-23 04:50:56 +07:00
|
|
|
if (ret == -EDEADLK) {
|
|
|
|
drm_modeset_backoff(&ctx);
|
|
|
|
goto retry;
|
|
|
|
}
|
|
|
|
drm_modeset_drop_locks(&ctx);
|
|
|
|
drm_modeset_acquire_fini(&ctx);
|
2017-04-07 02:06:54 +07:00
|
|
|
mutex_unlock(&crtc->dev->mode_config.mutex);
|
2017-03-23 04:50:56 +07:00
|
|
|
|
2008-11-08 05:05:41 +07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-08-29 15:27:51 +07:00
|
|
|
int drm_mode_crtc_set_obj_prop(struct drm_mode_object *obj,
|
|
|
|
struct drm_property *property,
|
|
|
|
uint64_t value)
|
2012-02-06 16:58:17 +07:00
|
|
|
{
|
2012-05-16 04:09:05 +07:00
|
|
|
int ret = -EINVAL;
|
|
|
|
struct drm_crtc *crtc = obj_to_crtc(obj);
|
2012-02-06 16:58:17 +07:00
|
|
|
|
2012-05-16 04:09:05 +07:00
|
|
|
if (crtc->funcs->set_property)
|
|
|
|
ret = crtc->funcs->set_property(crtc, property, value);
|
|
|
|
if (!ret)
|
|
|
|
drm_object_property_set_value(obj, property, value);
|
2012-02-06 16:58:17 +07:00
|
|
|
|
2012-05-16 04:09:05 +07:00
|
|
|
return ret;
|
2012-02-06 16:58:17 +07:00
|
|
|
}
|