2008-11-08 06:05:41 +08: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 16:15:10 +08:00
|
|
|
#include <linux/ctype.h>
|
2008-11-08 06:05:41 +08: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 16:04:11 +08:00
|
|
|
#include <linux/slab.h>
|
2011-08-31 06:16:33 +08:00
|
|
|
#include <linux/export.h>
|
2012-10-03 01:01:07 +08:00
|
|
|
#include <drm/drmP.h>
|
|
|
|
#include <drm/drm_crtc.h>
|
|
|
|
#include <drm/drm_edid.h>
|
|
|
|
#include <drm/drm_fourcc.h>
|
2013-11-20 01:10:12 +08:00
|
|
|
#include <drm/drm_modeset_lock.h>
|
2014-12-19 05:01:50 +08:00
|
|
|
#include <drm/drm_atomic.h>
|
2016-06-21 16:54:22 +08:00
|
|
|
#include <drm/drm_auth.h>
|
2016-08-15 22:07:02 +08:00
|
|
|
#include <drm/drm_framebuffer.h>
|
2008-11-08 06:05:41 +08:00
|
|
|
|
2014-01-23 22:35:24 +08:00
|
|
|
#include "drm_crtc_internal.h"
|
2014-09-10 18:43:53 +08:00
|
|
|
#include "drm_internal.h"
|
2014-01-23 22:35:24 +08:00
|
|
|
|
2008-11-08 06:05:41 +08:00
|
|
|
/* Avoid boilerplate. I'm tired of typing. */
|
|
|
|
#define DRM_ENUM_NAME_FN(fnname, list) \
|
2013-06-07 23:43:07 +08:00
|
|
|
const char *fnname(int val) \
|
2008-11-08 06:05:41 +08:00
|
|
|
{ \
|
|
|
|
int i; \
|
|
|
|
for (i = 0; i < ARRAY_SIZE(list); i++) { \
|
|
|
|
if (list[i].type == val) \
|
|
|
|
return list[i].name; \
|
|
|
|
} \
|
|
|
|
return "(unknown)"; \
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Global properties
|
|
|
|
*/
|
2014-12-10 20:03:34 +08:00
|
|
|
static const struct drm_prop_enum_list drm_dpms_enum_list[] = {
|
|
|
|
{ DRM_MODE_DPMS_ON, "On" },
|
2008-11-08 06:05:41 +08:00
|
|
|
{ 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-12-10 20:03:34 +08:00
|
|
|
static const struct drm_prop_enum_list drm_plane_type_enum_list[] = {
|
2014-04-02 08:16:57 +08:00
|
|
|
{ DRM_PLANE_TYPE_OVERLAY, "Overlay" },
|
|
|
|
{ DRM_PLANE_TYPE_PRIMARY, "Primary" },
|
|
|
|
{ DRM_PLANE_TYPE_CURSOR, "Cursor" },
|
|
|
|
};
|
|
|
|
|
2008-11-08 06:05:41 +08:00
|
|
|
/*
|
|
|
|
* Optional properties
|
|
|
|
*/
|
2014-12-10 20:03:34 +08:00
|
|
|
static const struct drm_prop_enum_list drm_scaling_mode_enum_list[] = {
|
2009-07-02 01:04:40 +08:00
|
|
|
{ DRM_MODE_SCALE_NONE, "None" },
|
|
|
|
{ DRM_MODE_SCALE_FULLSCREEN, "Full" },
|
|
|
|
{ DRM_MODE_SCALE_CENTER, "Center" },
|
|
|
|
{ DRM_MODE_SCALE_ASPECT, "Full aspect" },
|
2008-11-08 06:05:41 +08:00
|
|
|
};
|
|
|
|
|
2014-06-11 13:16:48 +08:00
|
|
|
static const struct drm_prop_enum_list drm_aspect_ratio_enum_list[] = {
|
|
|
|
{ DRM_MODE_PICTURE_ASPECT_NONE, "Automatic" },
|
|
|
|
{ DRM_MODE_PICTURE_ASPECT_4_3, "4:3" },
|
|
|
|
{ DRM_MODE_PICTURE_ASPECT_16_9, "16:9" },
|
|
|
|
};
|
|
|
|
|
2008-11-08 06:05:41 +08:00
|
|
|
/*
|
|
|
|
* Non-global properties, but "required" for certain connectors.
|
|
|
|
*/
|
2014-12-10 20:03:34 +08:00
|
|
|
static const struct drm_prop_enum_list drm_dvi_i_select_enum_list[] = {
|
2008-11-08 06:05:41 +08: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)
|
|
|
|
|
2014-12-10 20:03:34 +08:00
|
|
|
static const struct drm_prop_enum_list drm_dvi_i_subconnector_enum_list[] = {
|
2008-11-08 06:05:41 +08: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)
|
|
|
|
|
2014-12-10 20:03:34 +08:00
|
|
|
static const struct drm_prop_enum_list drm_tv_select_enum_list[] = {
|
2008-11-08 06:05:41 +08: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 10:19:19 +08:00
|
|
|
{ DRM_MODE_SUBCONNECTOR_SCART, "SCART" }, /* TV-out */
|
2008-11-08 06:05:41 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
DRM_ENUM_NAME_FN(drm_get_tv_select_name, drm_tv_select_enum_list)
|
|
|
|
|
2014-12-10 20:03:34 +08:00
|
|
|
static const struct drm_prop_enum_list drm_tv_subconnector_enum_list[] = {
|
2008-11-08 06:05:41 +08: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 10:19:19 +08:00
|
|
|
{ DRM_MODE_SUBCONNECTOR_SCART, "SCART" }, /* TV-out */
|
2008-11-08 06:05:41 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
DRM_ENUM_NAME_FN(drm_get_tv_subconnector_name,
|
|
|
|
drm_tv_subconnector_enum_list)
|
|
|
|
|
|
|
|
struct drm_conn_prop_enum_list {
|
|
|
|
int type;
|
2013-06-07 23:43:07 +08:00
|
|
|
const char *name;
|
2013-08-08 10:34:48 +08:00
|
|
|
struct ida ida;
|
2008-11-08 06:05:41 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Connector and encoder types.
|
|
|
|
*/
|
2014-12-10 20:03:34 +08:00
|
|
|
static struct drm_conn_prop_enum_list drm_connector_enum_list[] = {
|
|
|
|
{ DRM_MODE_CONNECTOR_Unknown, "Unknown" },
|
2013-08-08 10:34:48 +08:00
|
|
|
{ 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 20:12:13 +08:00
|
|
|
{ DRM_MODE_CONNECTOR_DSI, "DSI" },
|
drm: Add an encoder and connector type enum for DPI.
Right now exynos is exposing DPI as a TMDS encoder and VGA connector,
which seems rather misleading. This isn't just an internal detail,
since xrandr actually exposes "VGA" as the output name. Define some
new enums so that vc4's DPI can have a more informative name.
I considered other names for the connector as well. For VC4, the
Adafruit DPI kippah takes the 28 GPIO pins and routes them to a
standard-ish 40-pin FPC connector, but "40-pin FPC" doesn't uniquely
identify an ordering of pins (apparently some other orderings exist),
doesn't explain things as well for the user (who, if anything, knows
their product is a DPI kippah/panel combo), and actually doesn't have
to exist (one could connect the 28 GPIOs directly to something else).
Simply "DPI" seems like a good compromise name to distinguish from the
HDMI, DSI, and TV connectors .
Signed-off-by: Eric Anholt <eric@anholt.net>
Reviewed-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2016-03-19 03:34:59 +08:00
|
|
|
{ DRM_MODE_CONNECTOR_DPI, "DPI" },
|
2008-11-08 06:05:41 +08:00
|
|
|
};
|
|
|
|
|
2014-12-10 20:03:34 +08:00
|
|
|
static const struct drm_prop_enum_list drm_encoder_enum_list[] = {
|
|
|
|
{ DRM_MODE_ENCODER_NONE, "None" },
|
2008-11-08 06:05:41 +08:00
|
|
|
{ DRM_MODE_ENCODER_DAC, "DAC" },
|
|
|
|
{ DRM_MODE_ENCODER_TMDS, "TMDS" },
|
|
|
|
{ DRM_MODE_ENCODER_LVDS, "LVDS" },
|
|
|
|
{ DRM_MODE_ENCODER_TVDAC, "TV" },
|
2011-10-22 16:36:19 +08:00
|
|
|
{ DRM_MODE_ENCODER_VIRTUAL, "Virtual" },
|
2013-08-27 20:12:13 +08:00
|
|
|
{ DRM_MODE_ENCODER_DSI, "DSI" },
|
2014-05-02 09:09:54 +08:00
|
|
|
{ DRM_MODE_ENCODER_DPMST, "DP MST" },
|
drm: Add an encoder and connector type enum for DPI.
Right now exynos is exposing DPI as a TMDS encoder and VGA connector,
which seems rather misleading. This isn't just an internal detail,
since xrandr actually exposes "VGA" as the output name. Define some
new enums so that vc4's DPI can have a more informative name.
I considered other names for the connector as well. For VC4, the
Adafruit DPI kippah takes the 28 GPIO pins and routes them to a
standard-ish 40-pin FPC connector, but "40-pin FPC" doesn't uniquely
identify an ordering of pins (apparently some other orderings exist),
doesn't explain things as well for the user (who, if anything, knows
their product is a DPI kippah/panel combo), and actually doesn't have
to exist (one could connect the 28 GPIOs directly to something else).
Simply "DPI" seems like a good compromise name to distinguish from the
HDMI, DSI, and TV connectors .
Signed-off-by: Eric Anholt <eric@anholt.net>
Reviewed-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2016-03-19 03:34:59 +08:00
|
|
|
{ DRM_MODE_ENCODER_DPI, "DPI" },
|
2008-11-08 06:05:41 +08:00
|
|
|
};
|
|
|
|
|
2014-12-10 20:03:34 +08:00
|
|
|
static const struct drm_prop_enum_list drm_subpixel_enum_list[] = {
|
2014-02-11 07:32:44 +08:00
|
|
|
{ SubPixelUnknown, "Unknown" },
|
|
|
|
{ SubPixelHorizontalRGB, "Horizontal RGB" },
|
|
|
|
{ SubPixelHorizontalBGR, "Horizontal BGR" },
|
|
|
|
{ SubPixelVerticalRGB, "Vertical RGB" },
|
|
|
|
{ SubPixelVerticalBGR, "Vertical BGR" },
|
|
|
|
{ SubPixelNone, "None" },
|
|
|
|
};
|
|
|
|
|
2013-08-08 10:34:48 +08: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-11 04:33:02 +08: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 23:43:07 +08:00
|
|
|
const char *drm_get_connector_status_name(enum drm_connector_status status)
|
2008-11-08 06:05:41 +08:00
|
|
|
{
|
|
|
|
if (status == connector_status_connected)
|
|
|
|
return "connected";
|
|
|
|
else if (status == connector_status_disconnected)
|
|
|
|
return "disconnected";
|
|
|
|
else
|
|
|
|
return "unknown";
|
|
|
|
}
|
2013-05-10 20:36:42 +08:00
|
|
|
EXPORT_SYMBOL(drm_get_connector_status_name);
|
2008-11-08 06:05:41 +08:00
|
|
|
|
2014-02-11 07:32:44 +08: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);
|
|
|
|
|
2014-07-24 09:53:45 +08:00
|
|
|
/*
|
|
|
|
* Internal function to assign a slot in the object idr and optionally
|
|
|
|
* register the object into the idr.
|
|
|
|
*/
|
2016-08-15 22:07:02 +08:00
|
|
|
int drm_mode_object_get_reg(struct drm_device *dev,
|
|
|
|
struct drm_mode_object *obj,
|
|
|
|
uint32_t obj_type,
|
|
|
|
bool register_obj,
|
|
|
|
void (*obj_free_cb)(struct kref *kref))
|
2014-07-24 09:53:45 +08:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
mutex_lock(&dev->mode_config.idr_mutex);
|
|
|
|
ret = idr_alloc(&dev->mode_config.crtc_idr, register_obj ? obj : NULL, 1, 0, GFP_KERNEL);
|
|
|
|
if (ret >= 0) {
|
|
|
|
/*
|
|
|
|
* Set up the object linking under the protection of the idr
|
|
|
|
* lock so that other users can't see inconsistent state.
|
|
|
|
*/
|
|
|
|
obj->id = ret;
|
|
|
|
obj->type = obj_type;
|
2016-04-15 13:10:36 +08:00
|
|
|
if (obj_free_cb) {
|
|
|
|
obj->free_cb = obj_free_cb;
|
|
|
|
kref_init(&obj->refcount);
|
|
|
|
}
|
2014-07-24 09:53:45 +08:00
|
|
|
}
|
|
|
|
mutex_unlock(&dev->mode_config.idr_mutex);
|
|
|
|
|
|
|
|
return ret < 0 ? ret : 0;
|
|
|
|
}
|
|
|
|
|
2008-11-08 06:05:41 +08:00
|
|
|
/**
|
2012-12-02 07:09:18 +08:00
|
|
|
* drm_mode_object_get - allocate a new modeset identifier
|
2008-11-08 06:05:41 +08:00
|
|
|
* @dev: DRM device
|
2012-12-02 07:09:18 +08:00
|
|
|
* @obj: object pointer, used to generate unique ID
|
|
|
|
* @obj_type: object type
|
2008-11-08 06:05:41 +08:00
|
|
|
*
|
|
|
|
* Create a unique identifier based on @ptr in @dev's identifier space. Used
|
2014-03-11 04:33:02 +08: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-08 06:05:41 +08:00
|
|
|
*
|
2014-03-11 04:33:02 +08:00
|
|
|
* Returns:
|
2015-10-15 17:56:56 +08:00
|
|
|
* Zero on success, error code on failure.
|
2008-11-08 06:05:41 +08:00
|
|
|
*/
|
2014-01-23 22:35:24 +08:00
|
|
|
int drm_mode_object_get(struct drm_device *dev,
|
|
|
|
struct drm_mode_object *obj, uint32_t obj_type)
|
2008-11-08 06:05:41 +08:00
|
|
|
{
|
2016-04-15 13:10:36 +08:00
|
|
|
return drm_mode_object_get_reg(dev, obj, obj_type, true, NULL);
|
2014-07-24 09:53:45 +08:00
|
|
|
}
|
2008-11-08 06:05:41 +08:00
|
|
|
|
2016-08-15 22:07:02 +08:00
|
|
|
void drm_mode_object_register(struct drm_device *dev,
|
|
|
|
struct drm_mode_object *obj)
|
2014-07-24 09:53:45 +08:00
|
|
|
{
|
2009-01-19 15:21:45 +08:00
|
|
|
mutex_lock(&dev->mode_config.idr_mutex);
|
2014-07-24 09:53:45 +08:00
|
|
|
idr_replace(&dev->mode_config.crtc_idr, obj, obj->id);
|
2009-01-19 15:21:45 +08:00
|
|
|
mutex_unlock(&dev->mode_config.idr_mutex);
|
2008-11-08 06:05:41 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2016-04-15 13:10:32 +08:00
|
|
|
* drm_mode_object_unregister - free a modeset identifer
|
2008-11-08 06:05:41 +08:00
|
|
|
* @dev: DRM device
|
2012-12-02 07:09:18 +08:00
|
|
|
* @object: object to free
|
2008-11-08 06:05:41 +08:00
|
|
|
*
|
2016-04-15 13:10:32 +08:00
|
|
|
* Free @id from @dev's unique identifier pool.
|
|
|
|
* This function can be called multiple times, and guards against
|
|
|
|
* multiple removals.
|
|
|
|
* These modeset identifiers are _not_ reference counted. Hence don't use this
|
2014-03-11 04:33:02 +08:00
|
|
|
* for reference counted modeset objects like framebuffers.
|
2008-11-08 06:05:41 +08:00
|
|
|
*/
|
2016-04-15 13:10:32 +08:00
|
|
|
void drm_mode_object_unregister(struct drm_device *dev,
|
2014-01-23 22:35:24 +08:00
|
|
|
struct drm_mode_object *object)
|
2008-11-08 06:05:41 +08:00
|
|
|
{
|
2009-01-19 15:21:45 +08:00
|
|
|
mutex_lock(&dev->mode_config.idr_mutex);
|
2016-04-15 13:10:32 +08:00
|
|
|
if (object->id) {
|
|
|
|
idr_remove(&dev->mode_config.crtc_idr, object->id);
|
|
|
|
object->id = 0;
|
|
|
|
}
|
2009-01-19 15:21:45 +08:00
|
|
|
mutex_unlock(&dev->mode_config.idr_mutex);
|
2008-11-08 06:05:41 +08:00
|
|
|
}
|
|
|
|
|
2016-08-15 22:07:02 +08:00
|
|
|
struct drm_mode_object *__drm_mode_object_find(struct drm_device *dev,
|
|
|
|
uint32_t id, uint32_t type)
|
2014-05-30 23:37:03 +08:00
|
|
|
{
|
|
|
|
struct drm_mode_object *obj = NULL;
|
|
|
|
|
|
|
|
mutex_lock(&dev->mode_config.idr_mutex);
|
|
|
|
obj = idr_find(&dev->mode_config.crtc_idr, id);
|
2014-07-24 18:12:45 +08:00
|
|
|
if (obj && type != DRM_MODE_OBJECT_ANY && obj->type != type)
|
|
|
|
obj = NULL;
|
|
|
|
if (obj && obj->id != id)
|
|
|
|
obj = NULL;
|
2016-04-15 13:10:40 +08:00
|
|
|
|
|
|
|
if (obj && obj->free_cb) {
|
|
|
|
if (!kref_get_unless_zero(&obj->refcount))
|
|
|
|
obj = NULL;
|
|
|
|
}
|
2014-05-30 23:37:03 +08:00
|
|
|
mutex_unlock(&dev->mode_config.idr_mutex);
|
|
|
|
|
|
|
|
return obj;
|
|
|
|
}
|
|
|
|
|
2012-12-03 04:53:40 +08: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
|
|
|
|
*
|
2016-04-23 04:10:27 +08:00
|
|
|
* This function is used to look up a modeset object. It will acquire a
|
|
|
|
* reference for reference counted objects. This reference must be dropped again
|
|
|
|
* by callind drm_mode_object_unreference().
|
2012-12-03 04:53:40 +08:00
|
|
|
*/
|
2009-09-16 04:57:31 +08:00
|
|
|
struct drm_mode_object *drm_mode_object_find(struct drm_device *dev,
|
|
|
|
uint32_t id, uint32_t type)
|
2008-11-08 06:05:41 +08:00
|
|
|
{
|
2009-01-19 15:21:45 +08:00
|
|
|
struct drm_mode_object *obj = NULL;
|
2008-11-08 06:05:41 +08:00
|
|
|
|
2016-08-15 22:07:02 +08:00
|
|
|
obj = __drm_mode_object_find(dev, id, type);
|
2008-11-08 06:05:41 +08:00
|
|
|
return obj;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_mode_object_find);
|
|
|
|
|
2016-04-23 04:10:27 +08:00
|
|
|
/**
|
|
|
|
* drm_mode_object_unreference - decr the object refcnt
|
|
|
|
* @obj: mode_object
|
|
|
|
*
|
|
|
|
* This functions decrements the object's refcount if it is a refcounted modeset
|
|
|
|
* object. It is a no-op on any other object. This is used to drop references
|
|
|
|
* acquired with drm_mode_object_reference().
|
|
|
|
*/
|
2016-04-15 13:10:36 +08:00
|
|
|
void drm_mode_object_unreference(struct drm_mode_object *obj)
|
|
|
|
{
|
|
|
|
if (obj->free_cb) {
|
|
|
|
DRM_DEBUG("OBJ ID: %d (%d)\n", obj->id, atomic_read(&obj->refcount.refcount));
|
|
|
|
kref_put(&obj->refcount, obj->free_cb);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_mode_object_unreference);
|
|
|
|
|
|
|
|
/**
|
2016-04-23 04:10:27 +08:00
|
|
|
* drm_mode_object_reference - incr the object refcnt
|
2016-04-15 13:10:36 +08:00
|
|
|
* @obj: mode_object
|
|
|
|
*
|
2016-04-23 04:10:27 +08:00
|
|
|
* This functions increments the object's refcount if it is a refcounted modeset
|
|
|
|
* object. It is a no-op on any other object. References should be dropped again
|
|
|
|
* by calling drm_mode_object_unreference().
|
2016-04-15 13:10:36 +08:00
|
|
|
*/
|
|
|
|
void drm_mode_object_reference(struct drm_mode_object *obj)
|
|
|
|
{
|
|
|
|
if (obj->free_cb) {
|
|
|
|
DRM_DEBUG("OBJ ID: %d (%d)\n", obj->id, atomic_read(&obj->refcount.refcount));
|
|
|
|
kref_get(&obj->refcount);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_mode_object_reference);
|
|
|
|
|
2016-06-09 00:47:27 +08:00
|
|
|
/**
|
|
|
|
* drm_crtc_force_disable - Forcibly turn off a CRTC
|
|
|
|
* @crtc: CRTC to turn off
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* Zero on success, error code on failure.
|
|
|
|
*/
|
|
|
|
int drm_crtc_force_disable(struct drm_crtc *crtc)
|
|
|
|
{
|
|
|
|
struct drm_mode_set set = {
|
|
|
|
.crtc = crtc,
|
|
|
|
};
|
|
|
|
|
|
|
|
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.
|
|
|
|
*
|
|
|
|
* 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);
|
|
|
|
|
2013-11-20 01:10:12 +08:00
|
|
|
DEFINE_WW_CLASS(crtc_ww_class);
|
|
|
|
|
2015-12-09 00:41:53 +08: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-06-21 22:37:09 +08:00
|
|
|
static int drm_crtc_register_all(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
struct drm_crtc *crtc;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
drm_for_each_crtc(crtc, dev) {
|
|
|
|
if (crtc->funcs->late_register)
|
|
|
|
ret = crtc->funcs->late_register(crtc);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void drm_crtc_unregister_all(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
struct drm_crtc *crtc;
|
|
|
|
|
|
|
|
drm_for_each_crtc(crtc, dev) {
|
|
|
|
if (crtc->funcs->early_unregister)
|
|
|
|
crtc->funcs->early_unregister(crtc);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-11-08 06:05:41 +08:00
|
|
|
/**
|
2014-04-02 06:22:38 +08:00
|
|
|
* drm_crtc_init_with_planes - Initialise a new CRTC object with
|
|
|
|
* specified primary and cursor planes.
|
2008-11-08 06:05:41 +08:00
|
|
|
* @dev: DRM device
|
|
|
|
* @crtc: CRTC object to init
|
2014-04-02 06:22:38 +08:00
|
|
|
* @primary: Primary plane for CRTC
|
|
|
|
* @cursor: Cursor plane for CRTC
|
2008-11-08 06:05:41 +08: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 22:19:31 +08:00
|
|
|
* @name: printf style format string for the CRTC name, or NULL for default name
|
2008-11-08 06:05:41 +08:00
|
|
|
*
|
2013-06-05 20:39:55 +08:00
|
|
|
* Inits a new object created as base part of a driver crtc object.
|
2012-03-13 18:35:48 +08:00
|
|
|
*
|
2014-03-11 04:33:02 +08:00
|
|
|
* Returns:
|
2012-03-13 18:35:48 +08:00
|
|
|
* Zero on success, error code on failure.
|
2008-11-08 06:05:41 +08:00
|
|
|
*/
|
2014-04-02 06:22:38 +08:00
|
|
|
int drm_crtc_init_with_planes(struct drm_device *dev, struct drm_crtc *crtc,
|
|
|
|
struct drm_plane *primary,
|
2014-06-10 23:28:11 +08:00
|
|
|
struct drm_plane *cursor,
|
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 22:19:31 +08:00
|
|
|
const struct drm_crtc_funcs *funcs,
|
|
|
|
const char *name, ...)
|
2008-11-08 06:05:41 +08:00
|
|
|
{
|
2013-11-20 01:10:12 +08:00
|
|
|
struct drm_mode_config *config = &dev->mode_config;
|
2012-03-13 18:35:48 +08:00
|
|
|
int ret;
|
|
|
|
|
2015-03-17 19:05:29 +08:00
|
|
|
WARN_ON(primary && primary->type != DRM_PLANE_TYPE_PRIMARY);
|
|
|
|
WARN_ON(cursor && cursor->type != DRM_PLANE_TYPE_CURSOR);
|
|
|
|
|
2008-11-08 06:05:41 +08:00
|
|
|
crtc->dev = dev;
|
|
|
|
crtc->funcs = funcs;
|
|
|
|
|
2016-06-08 20:19:00 +08:00
|
|
|
INIT_LIST_HEAD(&crtc->commit_list);
|
|
|
|
spin_lock_init(&crtc->commit_lock);
|
|
|
|
|
2013-11-20 01:10:12 +08:00
|
|
|
drm_modeset_lock_init(&crtc->mutex);
|
2012-03-13 18:35:48 +08:00
|
|
|
ret = drm_mode_object_get(dev, &crtc->base, DRM_MODE_OBJECT_CRTC);
|
|
|
|
if (ret)
|
2014-11-12 18:59:47 +08:00
|
|
|
return ret;
|
2008-11-08 06:05:41 +08:00
|
|
|
|
2015-12-09 00:41:53 +08: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 13:10:32 +08:00
|
|
|
drm_mode_object_unregister(dev, &crtc->base);
|
2015-12-09 00:41:53 +08:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2012-05-16 05:09:05 +08:00
|
|
|
crtc->base.properties = &crtc->properties;
|
|
|
|
|
2013-11-20 01:10:12 +08:00
|
|
|
list_add_tail(&crtc->head, &config->crtc_list);
|
2016-05-28 03:05:00 +08:00
|
|
|
crtc->index = config->num_crtc++;
|
2012-03-13 18:35:48 +08:00
|
|
|
|
2014-04-02 06:22:38 +08:00
|
|
|
crtc->primary = primary;
|
2014-06-10 23:28:11 +08:00
|
|
|
crtc->cursor = cursor;
|
2014-04-02 06:22:38 +08:00
|
|
|
if (primary)
|
|
|
|
primary->possible_crtcs = 1 << drm_crtc_index(crtc);
|
2014-06-10 23:28:11 +08:00
|
|
|
if (cursor)
|
|
|
|
cursor->possible_crtcs = 1 << drm_crtc_index(crtc);
|
2014-04-02 06:22:38 +08:00
|
|
|
|
2015-01-22 23:36:21 +08:00
|
|
|
if (drm_core_check_feature(dev, DRIVER_ATOMIC)) {
|
|
|
|
drm_object_attach_property(&crtc->base, config->prop_active, 0);
|
2015-05-26 02:11:52 +08:00
|
|
|
drm_object_attach_property(&crtc->base, config->prop_mode_id, 0);
|
2015-01-22 23:36:21 +08:00
|
|
|
}
|
|
|
|
|
2014-11-12 18:59:47 +08:00
|
|
|
return 0;
|
2008-11-08 06:05:41 +08:00
|
|
|
}
|
2014-04-02 06:22:38 +08:00
|
|
|
EXPORT_SYMBOL(drm_crtc_init_with_planes);
|
2008-11-08 06:05:41 +08:00
|
|
|
|
|
|
|
/**
|
2013-06-05 20:39:55 +08:00
|
|
|
* drm_crtc_cleanup - Clean up the core crtc usage
|
2008-11-08 06:05:41 +08:00
|
|
|
* @crtc: CRTC to cleanup
|
|
|
|
*
|
2013-06-05 20:39:55 +08: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 06:05:41 +08:00
|
|
|
*/
|
|
|
|
void drm_crtc_cleanup(struct drm_crtc *crtc)
|
|
|
|
{
|
|
|
|
struct drm_device *dev = crtc->dev;
|
|
|
|
|
2016-05-28 03:05:00 +08: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.
|
|
|
|
*/
|
|
|
|
|
2012-11-19 17:44:56 +08:00
|
|
|
kfree(crtc->gamma_store);
|
|
|
|
crtc->gamma_store = NULL;
|
2008-11-08 06:05:41 +08:00
|
|
|
|
2013-11-20 01:10:12 +08:00
|
|
|
drm_modeset_lock_fini(&crtc->mutex);
|
|
|
|
|
2016-04-15 13:10:32 +08:00
|
|
|
drm_mode_object_unregister(dev, &crtc->base);
|
2008-11-08 06:05:41 +08:00
|
|
|
list_del(&crtc->head);
|
|
|
|
dev->mode_config.num_crtc--;
|
2014-11-25 19:09:49 +08: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 18:38:49 +08:00
|
|
|
|
2015-12-09 00:41:53 +08:00
|
|
|
kfree(crtc->name);
|
|
|
|
|
2014-12-10 18:38:49 +08:00
|
|
|
memset(crtc, 0, sizeof(*crtc));
|
2008-11-08 06:05:41 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_crtc_cleanup);
|
|
|
|
|
2013-08-20 07:53:06 +08:00
|
|
|
/*
|
2008-11-08 06:05:41 +08: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-20 07:53:06 +08:00
|
|
|
static void drm_mode_remove(struct drm_connector *connector,
|
|
|
|
struct drm_display_mode *mode)
|
2008-11-08 06:05:41 +08:00
|
|
|
{
|
|
|
|
list_del(&mode->head);
|
2012-02-01 18:38:19 +08:00
|
|
|
drm_mode_destroy(connector->dev, mode);
|
2008-11-08 06:05:41 +08:00
|
|
|
}
|
|
|
|
|
2014-07-22 18:09:10 +08:00
|
|
|
/**
|
|
|
|
* drm_display_info_set_bus_formats - set the supported bus formats
|
|
|
|
* @info: display info to store bus formats in
|
2015-01-24 04:09:30 +08:00
|
|
|
* @formats: array containing the supported bus formats
|
|
|
|
* @num_formats: the number of entries in the fmts array
|
2014-07-22 18:09:10 +08:00
|
|
|
*
|
|
|
|
* Store the supported bus formats in display info structure.
|
|
|
|
* See MEDIA_BUS_FMT_* definitions in include/uapi/linux/media-bus-format.h for
|
|
|
|
* a full list of available formats.
|
|
|
|
*/
|
|
|
|
int drm_display_info_set_bus_formats(struct drm_display_info *info,
|
|
|
|
const u32 *formats,
|
|
|
|
unsigned int num_formats)
|
|
|
|
{
|
|
|
|
u32 *fmts = NULL;
|
|
|
|
|
|
|
|
if (!formats && num_formats)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (formats && num_formats) {
|
|
|
|
fmts = kmemdup(formats, sizeof(*formats) * num_formats,
|
|
|
|
GFP_KERNEL);
|
2015-01-28 14:43:35 +08:00
|
|
|
if (!fmts)
|
2014-07-22 18:09:10 +08:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
kfree(info->bus_formats);
|
|
|
|
info->bus_formats = fmts;
|
|
|
|
info->num_bus_formats = num_formats;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_display_info_set_bus_formats);
|
|
|
|
|
2014-08-06 16:08:32 +08:00
|
|
|
/**
|
|
|
|
* drm_connector_get_cmdline_mode - reads the user's cmdline mode
|
|
|
|
* @connector: connector to quwery
|
|
|
|
*
|
|
|
|
* The kernel supports per-connector configration of its consoles through
|
|
|
|
* use of the video= parameter. This function parses that option and
|
|
|
|
* extracts the user's specified mode (or enable/disable status) for a
|
|
|
|
* particular connector. This is typically only used during the early fbdev
|
|
|
|
* setup.
|
|
|
|
*/
|
|
|
|
static void drm_connector_get_cmdline_mode(struct drm_connector *connector)
|
|
|
|
{
|
|
|
|
struct drm_cmdline_mode *mode = &connector->cmdline_mode;
|
|
|
|
char *option = NULL;
|
|
|
|
|
|
|
|
if (fb_get_options(connector->name, &option))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (!drm_mode_parse_command_line_for_connector(option,
|
|
|
|
connector,
|
|
|
|
mode))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (mode->force) {
|
|
|
|
const char *s;
|
|
|
|
|
|
|
|
switch (mode->force) {
|
|
|
|
case DRM_FORCE_OFF:
|
|
|
|
s = "OFF";
|
|
|
|
break;
|
|
|
|
case DRM_FORCE_ON_DIGITAL:
|
|
|
|
s = "ON - dig";
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
case DRM_FORCE_ON:
|
|
|
|
s = "ON";
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
DRM_INFO("forcing %s connector %s\n", connector->name, s);
|
|
|
|
connector->force = mode->force;
|
|
|
|
}
|
|
|
|
|
|
|
|
DRM_DEBUG_KMS("cmdline mode for connector %s %dx%d@%dHz%s%s%s\n",
|
|
|
|
connector->name,
|
|
|
|
mode->xres, mode->yres,
|
|
|
|
mode->refresh_specified ? mode->refresh : 60,
|
|
|
|
mode->rb ? " reduced blanking" : "",
|
|
|
|
mode->margins ? " with margins" : "",
|
|
|
|
mode->interlace ? " interlaced" : "");
|
|
|
|
}
|
|
|
|
|
2016-04-27 09:10:09 +08:00
|
|
|
static void drm_connector_free(struct kref *kref)
|
|
|
|
{
|
|
|
|
struct drm_connector *connector =
|
|
|
|
container_of(kref, struct drm_connector, base.refcount);
|
|
|
|
struct drm_device *dev = connector->dev;
|
|
|
|
|
|
|
|
drm_mode_object_unregister(dev, &connector->base);
|
|
|
|
connector->funcs->destroy(connector);
|
|
|
|
}
|
|
|
|
|
2008-11-08 06:05:41 +08:00
|
|
|
/**
|
|
|
|
* drm_connector_init - Init a preallocated connector
|
|
|
|
* @dev: DRM device
|
|
|
|
* @connector: the connector to init
|
|
|
|
* @funcs: callbacks for this connector
|
2012-12-02 07:09:18 +08:00
|
|
|
* @connector_type: user visible type of the connector
|
2008-11-08 06:05:41 +08:00
|
|
|
*
|
|
|
|
* Initialises a preallocated connector. Connectors should be
|
|
|
|
* subclassed as part of driver connector objects.
|
2012-03-13 18:35:48 +08:00
|
|
|
*
|
2014-03-11 04:33:02 +08:00
|
|
|
* Returns:
|
2012-03-13 18:35:48 +08:00
|
|
|
* Zero on success, error code on failure.
|
2008-11-08 06:05:41 +08:00
|
|
|
*/
|
2012-03-13 18:35:48 +08:00
|
|
|
int drm_connector_init(struct drm_device *dev,
|
|
|
|
struct drm_connector *connector,
|
|
|
|
const struct drm_connector_funcs *funcs,
|
|
|
|
int connector_type)
|
2008-11-08 06:05:41 +08:00
|
|
|
{
|
2014-12-19 05:01:54 +08:00
|
|
|
struct drm_mode_config *config = &dev->mode_config;
|
2012-03-13 18:35:48 +08:00
|
|
|
int ret;
|
2013-08-08 10:34:48 +08:00
|
|
|
struct ida *connector_ida =
|
|
|
|
&drm_connector_enum_list[connector_type].ida;
|
2012-03-13 18:35:48 +08:00
|
|
|
|
2012-12-02 07:28:11 +08:00
|
|
|
drm_modeset_lock_all(dev);
|
2008-11-08 06:05:41 +08:00
|
|
|
|
2016-04-27 09:10:09 +08:00
|
|
|
ret = drm_mode_object_get_reg(dev, &connector->base,
|
|
|
|
DRM_MODE_OBJECT_CONNECTOR,
|
|
|
|
false, drm_connector_free);
|
2012-03-13 18:35:48 +08:00
|
|
|
if (ret)
|
2014-05-14 21:58:19 +08:00
|
|
|
goto out_unlock;
|
2012-03-13 18:35:48 +08:00
|
|
|
|
2012-05-16 05:09:01 +08:00
|
|
|
connector->base.properties = &connector->properties;
|
2008-11-08 06:05:41 +08:00
|
|
|
connector->dev = dev;
|
|
|
|
connector->funcs = funcs;
|
2016-02-17 15:32:05 +08:00
|
|
|
|
2016-07-20 00:25:01 +08:00
|
|
|
ret = ida_simple_get(&config->connector_ida, 0, 0, GFP_KERNEL);
|
|
|
|
if (ret < 0)
|
2016-02-17 15:32:05 +08:00
|
|
|
goto out_put;
|
2016-07-20 00:25:01 +08:00
|
|
|
connector->index = ret;
|
|
|
|
ret = 0;
|
2016-02-17 15:32:05 +08:00
|
|
|
|
2008-11-08 06:05:41 +08:00
|
|
|
connector->connector_type = connector_type;
|
|
|
|
connector->connector_type_id =
|
2013-08-08 10:34:48 +08:00
|
|
|
ida_simple_get(connector_ida, 1, 0, GFP_KERNEL);
|
|
|
|
if (connector->connector_type_id < 0) {
|
|
|
|
ret = connector->connector_type_id;
|
2016-02-17 15:32:05 +08:00
|
|
|
goto out_put_id;
|
2013-08-08 10:34:48 +08:00
|
|
|
}
|
2014-05-14 21:58:19 +08:00
|
|
|
connector->name =
|
|
|
|
kasprintf(GFP_KERNEL, "%s-%d",
|
|
|
|
drm_connector_enum_list[connector_type].name,
|
|
|
|
connector->connector_type_id);
|
|
|
|
if (!connector->name) {
|
|
|
|
ret = -ENOMEM;
|
2016-02-17 15:32:05 +08:00
|
|
|
goto out_put_type_id;
|
2014-05-14 21:58:19 +08:00
|
|
|
}
|
|
|
|
|
2008-11-08 06:05:41 +08:00
|
|
|
INIT_LIST_HEAD(&connector->probed_modes);
|
|
|
|
INIT_LIST_HEAD(&connector->modes);
|
|
|
|
connector->edid_blob_ptr = NULL;
|
2012-10-24 02:23:35 +08:00
|
|
|
connector->status = connector_status_unknown;
|
2008-11-08 06:05:41 +08:00
|
|
|
|
2014-08-06 16:08:32 +08:00
|
|
|
drm_connector_get_cmdline_mode(connector);
|
|
|
|
|
2014-11-20 01:38:06 +08:00
|
|
|
/* We should add connectors at the end to avoid upsetting the connector
|
|
|
|
* index too much. */
|
2014-12-19 05:01:54 +08:00
|
|
|
list_add_tail(&connector->head, &config->connector_list);
|
|
|
|
config->num_connector++;
|
2008-11-08 06:05:41 +08:00
|
|
|
|
2011-10-22 16:36:19 +08:00
|
|
|
if (connector_type != DRM_MODE_CONNECTOR_VIRTUAL)
|
2012-10-12 09:50:56 +08:00
|
|
|
drm_object_attach_property(&connector->base,
|
2014-12-19 05:01:54 +08:00
|
|
|
config->edid_property,
|
2011-10-22 16:36:19 +08:00
|
|
|
0);
|
2008-11-08 06:05:41 +08:00
|
|
|
|
2012-10-12 09:50:56 +08:00
|
|
|
drm_object_attach_property(&connector->base,
|
2014-12-19 05:01:54 +08:00
|
|
|
config->dpms_property, 0);
|
|
|
|
|
|
|
|
if (drm_core_check_feature(dev, DRIVER_ATOMIC)) {
|
|
|
|
drm_object_attach_property(&connector->base, config->prop_crtc_id, 0);
|
|
|
|
}
|
2008-11-08 06:05:41 +08:00
|
|
|
|
2014-06-19 00:52:32 +08:00
|
|
|
connector->debugfs_entry = NULL;
|
2016-02-17 15:32:05 +08:00
|
|
|
out_put_type_id:
|
|
|
|
if (ret)
|
|
|
|
ida_remove(connector_ida, connector->connector_type_id);
|
|
|
|
out_put_id:
|
|
|
|
if (ret)
|
2016-07-20 00:25:01 +08:00
|
|
|
ida_remove(&config->connector_ida, connector->index);
|
2014-05-14 21:58:19 +08:00
|
|
|
out_put:
|
|
|
|
if (ret)
|
2016-04-15 13:10:32 +08:00
|
|
|
drm_mode_object_unregister(dev, &connector->base);
|
2014-05-14 21:58:19 +08:00
|
|
|
|
|
|
|
out_unlock:
|
2012-12-02 07:28:11 +08:00
|
|
|
drm_modeset_unlock_all(dev);
|
2012-03-13 18:35:48 +08:00
|
|
|
|
|
|
|
return ret;
|
2008-11-08 06:05:41 +08: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;
|
|
|
|
|
2016-06-15 20:17:49 +08:00
|
|
|
/* The connector should have been removed from userspace long before
|
|
|
|
* it is finally destroyed.
|
|
|
|
*/
|
|
|
|
if (WARN_ON(connector->registered))
|
|
|
|
drm_connector_unregister(connector);
|
|
|
|
|
2014-10-20 14:29:33 +08:00
|
|
|
if (connector->tile_group) {
|
|
|
|
drm_mode_put_tile_group(dev, connector->tile_group);
|
|
|
|
connector->tile_group = NULL;
|
|
|
|
}
|
|
|
|
|
2008-11-08 06:05:41 +08:00
|
|
|
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 10:34:48 +08:00
|
|
|
ida_remove(&drm_connector_enum_list[connector->connector_type].ida,
|
|
|
|
connector->connector_type_id);
|
|
|
|
|
2016-02-17 15:32:05 +08:00
|
|
|
ida_remove(&dev->mode_config.connector_ida,
|
2016-07-20 00:25:01 +08:00
|
|
|
connector->index);
|
2016-02-17 15:32:05 +08:00
|
|
|
|
2014-07-22 18:09:10 +08:00
|
|
|
kfree(connector->display_info.bus_formats);
|
2016-04-15 13:10:32 +08:00
|
|
|
drm_mode_object_unregister(dev, &connector->base);
|
2014-05-14 21:58:19 +08:00
|
|
|
kfree(connector->name);
|
|
|
|
connector->name = NULL;
|
2008-11-08 06:05:41 +08:00
|
|
|
list_del(&connector->head);
|
2011-08-27 10:06:21 +08:00
|
|
|
dev->mode_config.num_connector--;
|
2014-11-25 19:09:49 +08:00
|
|
|
|
|
|
|
WARN_ON(connector->state && !connector->funcs->atomic_destroy_state);
|
|
|
|
if (connector->state && connector->funcs->atomic_destroy_state)
|
|
|
|
connector->funcs->atomic_destroy_state(connector,
|
|
|
|
connector->state);
|
2014-12-10 18:38:49 +08:00
|
|
|
|
|
|
|
memset(connector, 0, sizeof(*connector));
|
2008-11-08 06:05:41 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_connector_cleanup);
|
|
|
|
|
2014-05-29 23:57:41 +08:00
|
|
|
/**
|
|
|
|
* drm_connector_register - register a connector
|
|
|
|
* @connector: the connector to register
|
|
|
|
*
|
|
|
|
* Register userspace interfaces for a connector
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* Zero on success, error code on failure.
|
|
|
|
*/
|
|
|
|
int drm_connector_register(struct drm_connector *connector)
|
|
|
|
{
|
2014-06-19 00:52:32 +08:00
|
|
|
int ret;
|
|
|
|
|
2016-06-15 20:17:48 +08:00
|
|
|
if (connector->registered)
|
|
|
|
return 0;
|
|
|
|
|
2014-06-19 00:52:32 +08:00
|
|
|
ret = drm_sysfs_connector_add(connector);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
ret = drm_debugfs_connector_add(connector);
|
|
|
|
if (ret) {
|
2016-06-15 20:17:47 +08:00
|
|
|
goto err_sysfs;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (connector->funcs->late_register) {
|
|
|
|
ret = connector->funcs->late_register(connector);
|
|
|
|
if (ret)
|
|
|
|
goto err_debugfs;
|
2014-06-19 00:52:32 +08:00
|
|
|
}
|
|
|
|
|
2016-05-06 20:55:02 +08:00
|
|
|
drm_mode_object_register(connector->dev, &connector->base);
|
|
|
|
|
2016-06-15 20:17:48 +08:00
|
|
|
connector->registered = true;
|
2014-06-19 00:52:32 +08:00
|
|
|
return 0;
|
2016-06-15 20:17:47 +08:00
|
|
|
|
|
|
|
err_debugfs:
|
|
|
|
drm_debugfs_connector_remove(connector);
|
|
|
|
err_sysfs:
|
|
|
|
drm_sysfs_connector_remove(connector);
|
|
|
|
return ret;
|
2014-05-29 23:57:41 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_connector_register);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_connector_unregister - unregister a connector
|
|
|
|
* @connector: the connector to unregister
|
|
|
|
*
|
|
|
|
* Unregister userspace interfaces for a connector
|
|
|
|
*/
|
|
|
|
void drm_connector_unregister(struct drm_connector *connector)
|
|
|
|
{
|
2016-06-15 20:17:48 +08:00
|
|
|
if (!connector->registered)
|
|
|
|
return;
|
|
|
|
|
2016-06-15 20:17:47 +08:00
|
|
|
if (connector->funcs->early_unregister)
|
|
|
|
connector->funcs->early_unregister(connector);
|
|
|
|
|
2014-05-29 23:57:41 +08:00
|
|
|
drm_sysfs_connector_remove(connector);
|
2014-06-19 00:52:32 +08:00
|
|
|
drm_debugfs_connector_remove(connector);
|
2016-06-15 20:17:48 +08:00
|
|
|
|
|
|
|
connector->registered = false;
|
2014-05-29 23:57:41 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_connector_unregister);
|
|
|
|
|
2016-07-14 00:39:07 +08:00
|
|
|
static void drm_connector_unregister_all(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
struct drm_connector *connector;
|
|
|
|
|
|
|
|
/* FIXME: taking the mode config mutex ends up in a clash with sysfs */
|
|
|
|
list_for_each_entry(connector, &dev->mode_config.connector_list, head)
|
|
|
|
drm_connector_unregister(connector);
|
|
|
|
}
|
|
|
|
|
2016-06-24 22:36:18 +08:00
|
|
|
static int drm_connector_register_all(struct drm_device *dev)
|
2016-04-19 20:24:51 +08:00
|
|
|
{
|
|
|
|
struct drm_connector *connector;
|
|
|
|
int ret;
|
|
|
|
|
2016-08-05 00:35:48 +08:00
|
|
|
/* FIXME: taking the mode config mutex ends up in a clash with
|
|
|
|
* fbcon/backlight registration */
|
|
|
|
list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
|
2016-04-19 20:24:51 +08:00
|
|
|
ret = drm_connector_register(connector);
|
|
|
|
if (ret)
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err:
|
|
|
|
mutex_unlock(&dev->mode_config.mutex);
|
|
|
|
drm_connector_unregister_all(dev);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-06-21 22:37:09 +08:00
|
|
|
static int drm_encoder_register_all(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
struct drm_encoder *encoder;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
drm_for_each_encoder(encoder, dev) {
|
|
|
|
if (encoder->funcs->late_register)
|
|
|
|
ret = encoder->funcs->late_register(encoder);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void drm_encoder_unregister_all(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
struct drm_encoder *encoder;
|
|
|
|
|
|
|
|
drm_for_each_encoder(encoder, dev) {
|
|
|
|
if (encoder->funcs->early_unregister)
|
|
|
|
encoder->funcs->early_unregister(encoder);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-11 04:33:02 +08: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
|
drm: Pass 'name' to drm_encoder_init()
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.
@@
identifier dev, encoder, funcs;
@@
int drm_encoder_init(struct drm_device *dev,
struct drm_encoder *encoder,
const struct drm_encoder_funcs *funcs,
int encoder_type
+ ,const char *name, int DOTDOTDOT
)
{ ... }
@@
identifier dev, encoder, funcs;
@@
int drm_encoder_init(struct drm_device *dev,
struct drm_encoder *encoder,
const struct drm_encoder_funcs *funcs,
int encoder_type
+ ,const char *name, int DOTDOTDOT
);
@@
expression E1, E2, E3, E4;
@@
drm_encoder_init(E1, E2, E3, E4
+ ,NULL
)
v2: 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/1449670818-2966-1-git-send-email-ville.syrjala@linux.intel.com
2015-12-09 22:20:18 +08:00
|
|
|
* @name: printf style format string for the encoder name, or NULL for default name
|
2014-03-11 04:33:02 +08:00
|
|
|
*
|
|
|
|
* 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 18:35:48 +08:00
|
|
|
int drm_encoder_init(struct drm_device *dev,
|
2012-02-20 22:16:40 +08:00
|
|
|
struct drm_encoder *encoder,
|
|
|
|
const struct drm_encoder_funcs *funcs,
|
drm: Pass 'name' to drm_encoder_init()
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.
@@
identifier dev, encoder, funcs;
@@
int drm_encoder_init(struct drm_device *dev,
struct drm_encoder *encoder,
const struct drm_encoder_funcs *funcs,
int encoder_type
+ ,const char *name, int DOTDOTDOT
)
{ ... }
@@
identifier dev, encoder, funcs;
@@
int drm_encoder_init(struct drm_device *dev,
struct drm_encoder *encoder,
const struct drm_encoder_funcs *funcs,
int encoder_type
+ ,const char *name, int DOTDOTDOT
);
@@
expression E1, E2, E3, E4;
@@
drm_encoder_init(E1, E2, E3, E4
+ ,NULL
)
v2: 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/1449670818-2966-1-git-send-email-ville.syrjala@linux.intel.com
2015-12-09 22:20:18 +08:00
|
|
|
int encoder_type, const char *name, ...)
|
2008-11-08 06:05:41 +08:00
|
|
|
{
|
2012-03-13 18:35:48 +08:00
|
|
|
int ret;
|
|
|
|
|
2012-12-02 07:28:11 +08:00
|
|
|
drm_modeset_lock_all(dev);
|
2008-11-08 06:05:41 +08:00
|
|
|
|
2012-03-13 18:35:48 +08:00
|
|
|
ret = drm_mode_object_get(dev, &encoder->base, DRM_MODE_OBJECT_ENCODER);
|
|
|
|
if (ret)
|
2014-05-14 21:58:20 +08:00
|
|
|
goto out_unlock;
|
2008-11-08 06:05:41 +08:00
|
|
|
|
2012-03-13 18:35:48 +08:00
|
|
|
encoder->dev = dev;
|
2008-11-08 06:05:41 +08:00
|
|
|
encoder->encoder_type = encoder_type;
|
|
|
|
encoder->funcs = funcs;
|
2015-12-09 00:41:52 +08:00
|
|
|
if (name) {
|
|
|
|
va_list ap;
|
|
|
|
|
|
|
|
va_start(ap, name);
|
|
|
|
encoder->name = kvasprintf(GFP_KERNEL, name, ap);
|
|
|
|
va_end(ap);
|
|
|
|
} else {
|
|
|
|
encoder->name = kasprintf(GFP_KERNEL, "%s-%d",
|
|
|
|
drm_encoder_enum_list[encoder_type].name,
|
|
|
|
encoder->base.id);
|
|
|
|
}
|
2014-05-14 21:58:20 +08:00
|
|
|
if (!encoder->name) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out_put;
|
|
|
|
}
|
2008-11-08 06:05:41 +08:00
|
|
|
|
|
|
|
list_add_tail(&encoder->head, &dev->mode_config.encoder_list);
|
2016-05-28 03:05:00 +08:00
|
|
|
encoder->index = dev->mode_config.num_encoder++;
|
2008-11-08 06:05:41 +08:00
|
|
|
|
2014-05-14 21:58:20 +08:00
|
|
|
out_put:
|
|
|
|
if (ret)
|
2016-04-15 13:10:32 +08:00
|
|
|
drm_mode_object_unregister(dev, &encoder->base);
|
2014-05-14 21:58:20 +08:00
|
|
|
|
|
|
|
out_unlock:
|
2012-12-02 07:28:11 +08:00
|
|
|
drm_modeset_unlock_all(dev);
|
2012-03-13 18:35:48 +08:00
|
|
|
|
|
|
|
return ret;
|
2008-11-08 06:05:41 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_encoder_init);
|
|
|
|
|
2014-03-11 04:33:02 +08: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-08 06:05:41 +08:00
|
|
|
void drm_encoder_cleanup(struct drm_encoder *encoder)
|
|
|
|
{
|
|
|
|
struct drm_device *dev = encoder->dev;
|
2014-12-10 20:03:34 +08:00
|
|
|
|
2016-05-28 03:05:00 +08:00
|
|
|
/* Note that the encoder_list is considered to be static; should we
|
|
|
|
* remove the drm_encoder at runtime we would have to decrement all
|
|
|
|
* the indices on the drm_encoder after us in the encoder_list.
|
|
|
|
*/
|
|
|
|
|
2012-12-02 07:28:11 +08:00
|
|
|
drm_modeset_lock_all(dev);
|
2016-04-15 13:10:32 +08:00
|
|
|
drm_mode_object_unregister(dev, &encoder->base);
|
2014-05-14 21:58:20 +08:00
|
|
|
kfree(encoder->name);
|
2008-11-08 06:05:41 +08:00
|
|
|
list_del(&encoder->head);
|
2011-08-27 10:06:21 +08:00
|
|
|
dev->mode_config.num_encoder--;
|
2012-12-02 07:28:11 +08:00
|
|
|
drm_modeset_unlock_all(dev);
|
2014-12-10 18:38:49 +08:00
|
|
|
|
|
|
|
memset(encoder, 0, sizeof(*encoder));
|
2008-11-08 06:05:41 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_encoder_cleanup);
|
|
|
|
|
2015-12-09 00:41:54 +08:00
|
|
|
static unsigned int drm_num_planes(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
unsigned int num = 0;
|
|
|
|
struct drm_plane *tmp;
|
|
|
|
|
|
|
|
drm_for_each_plane(tmp, dev) {
|
|
|
|
num++;
|
|
|
|
}
|
|
|
|
|
|
|
|
return num;
|
|
|
|
}
|
|
|
|
|
2013-06-05 20:39:56 +08:00
|
|
|
/**
|
2014-04-02 06:22:36 +08:00
|
|
|
* drm_universal_plane_init - Initialize a new universal plane object
|
2013-06-05 20:39:56 +08:00
|
|
|
* @dev: DRM device
|
|
|
|
* @plane: plane object to init
|
|
|
|
* @possible_crtcs: bitmask of possible CRTCs
|
|
|
|
* @funcs: callbacks for the new plane
|
2016-08-13 04:48:37 +08:00
|
|
|
* @formats: array of supported formats (DRM_FORMAT\_\*)
|
2013-06-05 20:39:56 +08:00
|
|
|
* @format_count: number of elements in @formats
|
2014-04-02 06:22:36 +08:00
|
|
|
* @type: type of plane (overlay, primary, cursor)
|
drm: Pass 'name' to drm_universal_plane_init()
Done with coccinelle for the most part. It choked on
msm/mdp/mdp5/mdp5_plane.c like so:
"BAD:!!!!! enum drm_plane_type type;"
No idea how to deal with that, so I just fixed that up
by hand.
Also it thinks '...' is part of the semantic patch, so I put an
'int DOTDOTDOT' placeholder in its place and got rid of it with
sed afterwards.
I didn't convert drm_plane_init() since passing the varargs through
would mean either cpp macros or va_list, and I figured we don't
care about these legacy functions enough to warrant the extra pain.
@@
typedef uint32_t;
identifier dev, plane, possible_crtcs, funcs, formats, format_count, type;
@@
int drm_universal_plane_init(struct drm_device *dev,
struct drm_plane *plane,
unsigned long possible_crtcs,
const struct drm_plane_funcs *funcs,
const uint32_t *formats,
unsigned int format_count,
enum drm_plane_type type
+ ,const char *name, int DOTDOTDOT
)
{ ... }
@@
identifier dev, plane, possible_crtcs, funcs, formats, format_count, type;
@@
int drm_universal_plane_init(struct drm_device *dev,
struct drm_plane *plane,
unsigned long possible_crtcs,
const struct drm_plane_funcs *funcs,
const uint32_t *formats,
unsigned int format_count,
enum drm_plane_type type
+ ,const char *name, int DOTDOTDOT
);
@@
expression E1, E2, E3, E4, E5, E6, E7;
@@
drm_universal_plane_init(E1, E2, E3, E4, E5, E6, E7
+ ,NULL
)
v2: Split crtc and plane changes apart
Pass NUL for no-name instead of ""
Leave drm_plane_init() alone
v3: Add ', or NULL...' to @name kernel doc (Jani)
Annotate the function with __printf() attribute (Jani)
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Link: http://patchwork.freedesktop.org/patch/msgid/1449670795-2853-1-git-send-email-ville.syrjala@linux.intel.com
2015-12-09 22:19:55 +08:00
|
|
|
* @name: printf style format string for the plane name, or NULL for default name
|
2013-06-05 20:39:56 +08:00
|
|
|
*
|
2014-04-02 06:22:36 +08:00
|
|
|
* Initializes a plane object of type @type.
|
2013-06-05 20:39:56 +08:00
|
|
|
*
|
2014-03-11 04:33:02 +08:00
|
|
|
* Returns:
|
2013-06-05 20:39:56 +08:00
|
|
|
* Zero on success, error code on failure.
|
|
|
|
*/
|
2014-04-02 06:22:36 +08:00
|
|
|
int drm_universal_plane_init(struct drm_device *dev, struct drm_plane *plane,
|
|
|
|
unsigned long possible_crtcs,
|
|
|
|
const struct drm_plane_funcs *funcs,
|
2015-08-12 22:54:28 +08:00
|
|
|
const uint32_t *formats, unsigned int format_count,
|
drm: Pass 'name' to drm_universal_plane_init()
Done with coccinelle for the most part. It choked on
msm/mdp/mdp5/mdp5_plane.c like so:
"BAD:!!!!! enum drm_plane_type type;"
No idea how to deal with that, so I just fixed that up
by hand.
Also it thinks '...' is part of the semantic patch, so I put an
'int DOTDOTDOT' placeholder in its place and got rid of it with
sed afterwards.
I didn't convert drm_plane_init() since passing the varargs through
would mean either cpp macros or va_list, and I figured we don't
care about these legacy functions enough to warrant the extra pain.
@@
typedef uint32_t;
identifier dev, plane, possible_crtcs, funcs, formats, format_count, type;
@@
int drm_universal_plane_init(struct drm_device *dev,
struct drm_plane *plane,
unsigned long possible_crtcs,
const struct drm_plane_funcs *funcs,
const uint32_t *formats,
unsigned int format_count,
enum drm_plane_type type
+ ,const char *name, int DOTDOTDOT
)
{ ... }
@@
identifier dev, plane, possible_crtcs, funcs, formats, format_count, type;
@@
int drm_universal_plane_init(struct drm_device *dev,
struct drm_plane *plane,
unsigned long possible_crtcs,
const struct drm_plane_funcs *funcs,
const uint32_t *formats,
unsigned int format_count,
enum drm_plane_type type
+ ,const char *name, int DOTDOTDOT
);
@@
expression E1, E2, E3, E4, E5, E6, E7;
@@
drm_universal_plane_init(E1, E2, E3, E4, E5, E6, E7
+ ,NULL
)
v2: Split crtc and plane changes apart
Pass NUL for no-name instead of ""
Leave drm_plane_init() alone
v3: Add ', or NULL...' to @name kernel doc (Jani)
Annotate the function with __printf() attribute (Jani)
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Link: http://patchwork.freedesktop.org/patch/msgid/1449670795-2853-1-git-send-email-ville.syrjala@linux.intel.com
2015-12-09 22:19:55 +08:00
|
|
|
enum drm_plane_type type,
|
|
|
|
const char *name, ...)
|
2011-11-15 06:51:27 +08:00
|
|
|
{
|
2014-12-19 05:01:53 +08:00
|
|
|
struct drm_mode_config *config = &dev->mode_config;
|
2012-03-13 18:35:48 +08:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = drm_mode_object_get(dev, &plane->base, DRM_MODE_OBJECT_PLANE);
|
|
|
|
if (ret)
|
2014-11-12 18:59:47 +08:00
|
|
|
return ret;
|
2012-03-13 18:35:48 +08:00
|
|
|
|
2014-11-11 17:12:00 +08:00
|
|
|
drm_modeset_lock_init(&plane->mutex);
|
|
|
|
|
2012-05-17 16:23:27 +08:00
|
|
|
plane->base.properties = &plane->properties;
|
2011-11-15 06:51:27 +08:00
|
|
|
plane->dev = dev;
|
|
|
|
plane->funcs = funcs;
|
2014-12-10 20:03:36 +08:00
|
|
|
plane->format_types = kmalloc_array(format_count, sizeof(uint32_t),
|
|
|
|
GFP_KERNEL);
|
2011-11-15 06:51:27 +08:00
|
|
|
if (!plane->format_types) {
|
|
|
|
DRM_DEBUG_KMS("out of memory when allocating plane\n");
|
2016-04-15 13:10:32 +08:00
|
|
|
drm_mode_object_unregister(dev, &plane->base);
|
2014-11-12 18:59:47 +08:00
|
|
|
return -ENOMEM;
|
2011-11-15 06:51:27 +08:00
|
|
|
}
|
|
|
|
|
2015-12-09 00:41:54 +08:00
|
|
|
if (name) {
|
|
|
|
va_list ap;
|
|
|
|
|
|
|
|
va_start(ap, name);
|
|
|
|
plane->name = kvasprintf(GFP_KERNEL, name, ap);
|
|
|
|
va_end(ap);
|
|
|
|
} else {
|
|
|
|
plane->name = kasprintf(GFP_KERNEL, "plane-%d",
|
|
|
|
drm_num_planes(dev));
|
|
|
|
}
|
|
|
|
if (!plane->name) {
|
|
|
|
kfree(plane->format_types);
|
2016-04-15 13:10:32 +08:00
|
|
|
drm_mode_object_unregister(dev, &plane->base);
|
2015-12-09 00:41:54 +08:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2011-11-15 06:51:28 +08:00
|
|
|
memcpy(plane->format_types, formats, format_count * sizeof(uint32_t));
|
2011-11-15 06:51:27 +08:00
|
|
|
plane->format_count = format_count;
|
|
|
|
plane->possible_crtcs = possible_crtcs;
|
2014-04-02 06:22:36 +08:00
|
|
|
plane->type = type;
|
2011-11-15 06:51:27 +08:00
|
|
|
|
2014-12-19 05:01:53 +08:00
|
|
|
list_add_tail(&plane->head, &config->plane_list);
|
2016-05-28 03:05:00 +08:00
|
|
|
plane->index = config->num_total_plane++;
|
2014-04-02 06:22:36 +08:00
|
|
|
if (plane->type == DRM_PLANE_TYPE_OVERLAY)
|
2014-12-19 05:01:53 +08:00
|
|
|
config->num_overlay_plane++;
|
2011-11-15 06:51:27 +08:00
|
|
|
|
2014-04-02 08:16:57 +08:00
|
|
|
drm_object_attach_property(&plane->base,
|
2014-12-19 05:01:53 +08:00
|
|
|
config->plane_type_property,
|
2014-04-02 08:16:57 +08:00
|
|
|
plane->type);
|
|
|
|
|
2014-12-19 05:01:53 +08:00
|
|
|
if (drm_core_check_feature(dev, DRIVER_ATOMIC)) {
|
|
|
|
drm_object_attach_property(&plane->base, config->prop_fb_id, 0);
|
|
|
|
drm_object_attach_property(&plane->base, config->prop_crtc_id, 0);
|
|
|
|
drm_object_attach_property(&plane->base, config->prop_crtc_x, 0);
|
|
|
|
drm_object_attach_property(&plane->base, config->prop_crtc_y, 0);
|
|
|
|
drm_object_attach_property(&plane->base, config->prop_crtc_w, 0);
|
|
|
|
drm_object_attach_property(&plane->base, config->prop_crtc_h, 0);
|
|
|
|
drm_object_attach_property(&plane->base, config->prop_src_x, 0);
|
|
|
|
drm_object_attach_property(&plane->base, config->prop_src_y, 0);
|
|
|
|
drm_object_attach_property(&plane->base, config->prop_src_w, 0);
|
|
|
|
drm_object_attach_property(&plane->base, config->prop_src_h, 0);
|
|
|
|
}
|
|
|
|
|
2014-11-12 18:59:47 +08:00
|
|
|
return 0;
|
2011-11-15 06:51:27 +08:00
|
|
|
}
|
2014-04-02 06:22:36 +08:00
|
|
|
EXPORT_SYMBOL(drm_universal_plane_init);
|
|
|
|
|
2016-06-21 22:37:09 +08:00
|
|
|
static int drm_plane_register_all(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
struct drm_plane *plane;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
drm_for_each_plane(plane, dev) {
|
|
|
|
if (plane->funcs->late_register)
|
|
|
|
ret = plane->funcs->late_register(plane);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void drm_plane_unregister_all(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
struct drm_plane *plane;
|
|
|
|
|
|
|
|
drm_for_each_plane(plane, dev) {
|
|
|
|
if (plane->funcs->early_unregister)
|
|
|
|
plane->funcs->early_unregister(plane);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-04-02 06:22:36 +08:00
|
|
|
/**
|
|
|
|
* 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
|
2016-08-13 04:48:37 +08:00
|
|
|
* @formats: array of supported formats (DRM_FORMAT\_\*)
|
2014-04-02 06:22:36 +08:00
|
|
|
* @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,
|
2015-08-12 22:54:28 +08:00
|
|
|
const uint32_t *formats, unsigned int format_count,
|
2014-04-02 06:22:36 +08:00
|
|
|
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,
|
drm: Pass 'name' to drm_universal_plane_init()
Done with coccinelle for the most part. It choked on
msm/mdp/mdp5/mdp5_plane.c like so:
"BAD:!!!!! enum drm_plane_type type;"
No idea how to deal with that, so I just fixed that up
by hand.
Also it thinks '...' is part of the semantic patch, so I put an
'int DOTDOTDOT' placeholder in its place and got rid of it with
sed afterwards.
I didn't convert drm_plane_init() since passing the varargs through
would mean either cpp macros or va_list, and I figured we don't
care about these legacy functions enough to warrant the extra pain.
@@
typedef uint32_t;
identifier dev, plane, possible_crtcs, funcs, formats, format_count, type;
@@
int drm_universal_plane_init(struct drm_device *dev,
struct drm_plane *plane,
unsigned long possible_crtcs,
const struct drm_plane_funcs *funcs,
const uint32_t *formats,
unsigned int format_count,
enum drm_plane_type type
+ ,const char *name, int DOTDOTDOT
)
{ ... }
@@
identifier dev, plane, possible_crtcs, funcs, formats, format_count, type;
@@
int drm_universal_plane_init(struct drm_device *dev,
struct drm_plane *plane,
unsigned long possible_crtcs,
const struct drm_plane_funcs *funcs,
const uint32_t *formats,
unsigned int format_count,
enum drm_plane_type type
+ ,const char *name, int DOTDOTDOT
);
@@
expression E1, E2, E3, E4, E5, E6, E7;
@@
drm_universal_plane_init(E1, E2, E3, E4, E5, E6, E7
+ ,NULL
)
v2: Split crtc and plane changes apart
Pass NUL for no-name instead of ""
Leave drm_plane_init() alone
v3: Add ', or NULL...' to @name kernel doc (Jani)
Annotate the function with __printf() attribute (Jani)
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Link: http://patchwork.freedesktop.org/patch/msgid/1449670795-2853-1-git-send-email-ville.syrjala@linux.intel.com
2015-12-09 22:19:55 +08:00
|
|
|
formats, format_count, type, NULL);
|
2014-04-02 06:22:36 +08:00
|
|
|
}
|
2011-11-15 06:51:27 +08:00
|
|
|
EXPORT_SYMBOL(drm_plane_init);
|
|
|
|
|
2013-06-05 20:39:56 +08: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-15 06:51:27 +08:00
|
|
|
void drm_plane_cleanup(struct drm_plane *plane)
|
|
|
|
{
|
|
|
|
struct drm_device *dev = plane->dev;
|
|
|
|
|
2012-12-02 07:28:11 +08:00
|
|
|
drm_modeset_lock_all(dev);
|
2011-11-15 06:51:27 +08:00
|
|
|
kfree(plane->format_types);
|
2016-04-15 13:10:32 +08:00
|
|
|
drm_mode_object_unregister(dev, &plane->base);
|
2014-04-02 06:22:36 +08:00
|
|
|
|
|
|
|
BUG_ON(list_empty(&plane->head));
|
|
|
|
|
2016-05-28 03:05:00 +08:00
|
|
|
/* Note that the plane_list is considered to be static; should we
|
|
|
|
* remove the drm_plane at runtime we would have to decrement all
|
|
|
|
* the indices on the drm_plane after us in the plane_list.
|
|
|
|
*/
|
|
|
|
|
2014-04-02 06:22:36 +08:00
|
|
|
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-02 07:28:11 +08:00
|
|
|
drm_modeset_unlock_all(dev);
|
2014-11-25 19:09:49 +08:00
|
|
|
|
|
|
|
WARN_ON(plane->state && !plane->funcs->atomic_destroy_state);
|
|
|
|
if (plane->state && plane->funcs->atomic_destroy_state)
|
|
|
|
plane->funcs->atomic_destroy_state(plane, plane->state);
|
2014-12-10 18:38:49 +08:00
|
|
|
|
2015-12-09 00:41:54 +08:00
|
|
|
kfree(plane->name);
|
|
|
|
|
2014-12-10 18:38:49 +08:00
|
|
|
memset(plane, 0, sizeof(*plane));
|
2011-11-15 06:51:27 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_plane_cleanup);
|
|
|
|
|
2015-04-10 08:36:21 +08:00
|
|
|
/**
|
|
|
|
* drm_plane_from_index - find the registered plane at an index
|
|
|
|
* @dev: DRM device
|
|
|
|
* @idx: index of registered plane to find for
|
|
|
|
*
|
|
|
|
* Given a plane index, return the registered plane from DRM device's
|
|
|
|
* list of planes with matching index.
|
|
|
|
*/
|
|
|
|
struct drm_plane *
|
|
|
|
drm_plane_from_index(struct drm_device *dev, int idx)
|
|
|
|
{
|
|
|
|
struct drm_plane *plane;
|
|
|
|
|
2016-05-28 03:05:00 +08:00
|
|
|
drm_for_each_plane(plane, dev)
|
|
|
|
if (idx == plane->index)
|
2015-04-10 08:36:21 +08:00
|
|
|
return plane;
|
2016-05-28 03:05:00 +08:00
|
|
|
|
2015-04-10 08:36:21 +08:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_plane_from_index);
|
|
|
|
|
2013-06-05 20:39:56 +08: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 21:10:40 +08:00
|
|
|
void drm_plane_force_disable(struct drm_plane *plane)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
2014-07-27 19:42:42 +08:00
|
|
|
if (!plane->fb)
|
2013-06-03 21:10:40 +08:00
|
|
|
return;
|
|
|
|
|
2014-07-27 19:42:42 +08:00
|
|
|
plane->old_fb = plane->fb;
|
2013-06-03 21:10:40 +08:00
|
|
|
ret = plane->funcs->disable_plane(plane);
|
2014-04-23 16:24:11 +08:00
|
|
|
if (ret) {
|
2013-06-03 21:10:40 +08:00
|
|
|
DRM_ERROR("failed to disable plane with busy fb\n");
|
2014-07-27 19:42:42 +08:00
|
|
|
plane->old_fb = NULL;
|
2014-04-23 16:24:11 +08:00
|
|
|
return;
|
|
|
|
}
|
2013-06-03 21:10:40 +08:00
|
|
|
/* disconnect the plane from the fb and crtc: */
|
2015-02-27 19:58:13 +08:00
|
|
|
drm_framebuffer_unreference(plane->old_fb);
|
2014-07-27 19:42:42 +08:00
|
|
|
plane->old_fb = NULL;
|
2013-06-03 21:10:40 +08:00
|
|
|
plane->fb = NULL;
|
|
|
|
plane->crtc = NULL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_plane_force_disable);
|
|
|
|
|
2016-06-21 22:37:09 +08:00
|
|
|
int drm_modeset_register_all(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = drm_plane_register_all(dev);
|
|
|
|
if (ret)
|
|
|
|
goto err_plane;
|
|
|
|
|
|
|
|
ret = drm_crtc_register_all(dev);
|
|
|
|
if (ret)
|
|
|
|
goto err_crtc;
|
|
|
|
|
|
|
|
ret = drm_encoder_register_all(dev);
|
|
|
|
if (ret)
|
|
|
|
goto err_encoder;
|
|
|
|
|
|
|
|
ret = drm_connector_register_all(dev);
|
|
|
|
if (ret)
|
|
|
|
goto err_connector;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err_connector:
|
|
|
|
drm_encoder_unregister_all(dev);
|
|
|
|
err_encoder:
|
|
|
|
drm_crtc_unregister_all(dev);
|
|
|
|
err_crtc:
|
|
|
|
drm_plane_unregister_all(dev);
|
|
|
|
err_plane:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
void drm_modeset_unregister_all(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
drm_connector_unregister_all(dev);
|
|
|
|
drm_encoder_unregister_all(dev);
|
|
|
|
drm_crtc_unregister_all(dev);
|
|
|
|
drm_plane_unregister_all(dev);
|
|
|
|
}
|
|
|
|
|
2014-12-19 05:01:53 +08:00
|
|
|
static int drm_mode_create_standard_properties(struct drm_device *dev)
|
2008-11-08 06:05:41 +08:00
|
|
|
{
|
2014-12-19 05:01:52 +08:00
|
|
|
struct drm_property *prop;
|
2008-11-08 06:05:41 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Standard properties (apply to all connectors)
|
|
|
|
*/
|
2014-12-19 05:01:52 +08:00
|
|
|
prop = drm_property_create(dev, DRM_MODE_PROP_BLOB |
|
2008-11-08 06:05:41 +08:00
|
|
|
DRM_MODE_PROP_IMMUTABLE,
|
|
|
|
"EDID", 0);
|
2014-12-19 05:01:52 +08:00
|
|
|
if (!prop)
|
|
|
|
return -ENOMEM;
|
|
|
|
dev->mode_config.edid_property = prop;
|
2008-11-08 06:05:41 +08:00
|
|
|
|
2014-12-19 05:01:52 +08:00
|
|
|
prop = drm_property_create_enum(dev, 0,
|
2012-02-06 17:58:17 +08:00
|
|
|
"DPMS", drm_dpms_enum_list,
|
|
|
|
ARRAY_SIZE(drm_dpms_enum_list));
|
2014-12-19 05:01:52 +08:00
|
|
|
if (!prop)
|
|
|
|
return -ENOMEM;
|
|
|
|
dev->mode_config.dpms_property = prop;
|
2014-10-20 14:30:50 +08:00
|
|
|
|
2014-12-19 05:01:52 +08:00
|
|
|
prop = drm_property_create(dev,
|
|
|
|
DRM_MODE_PROP_BLOB |
|
|
|
|
DRM_MODE_PROP_IMMUTABLE,
|
|
|
|
"PATH", 0);
|
|
|
|
if (!prop)
|
|
|
|
return -ENOMEM;
|
|
|
|
dev->mode_config.path_property = prop;
|
2008-11-08 06:05:41 +08:00
|
|
|
|
2014-12-19 05:01:52 +08:00
|
|
|
prop = drm_property_create(dev,
|
|
|
|
DRM_MODE_PROP_BLOB |
|
|
|
|
DRM_MODE_PROP_IMMUTABLE,
|
|
|
|
"TILE", 0);
|
|
|
|
if (!prop)
|
|
|
|
return -ENOMEM;
|
|
|
|
dev->mode_config.tile_property = prop;
|
2014-04-02 08:16:57 +08:00
|
|
|
|
2014-12-19 05:01:53 +08:00
|
|
|
prop = drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE,
|
2014-04-02 08:16:57 +08:00
|
|
|
"type", drm_plane_type_enum_list,
|
|
|
|
ARRAY_SIZE(drm_plane_type_enum_list));
|
2014-12-19 05:01:53 +08:00
|
|
|
if (!prop)
|
|
|
|
return -ENOMEM;
|
|
|
|
dev->mode_config.plane_type_property = prop;
|
|
|
|
|
|
|
|
prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
|
|
|
|
"SRC_X", 0, UINT_MAX);
|
|
|
|
if (!prop)
|
|
|
|
return -ENOMEM;
|
|
|
|
dev->mode_config.prop_src_x = prop;
|
|
|
|
|
|
|
|
prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
|
|
|
|
"SRC_Y", 0, UINT_MAX);
|
|
|
|
if (!prop)
|
|
|
|
return -ENOMEM;
|
|
|
|
dev->mode_config.prop_src_y = prop;
|
|
|
|
|
|
|
|
prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
|
|
|
|
"SRC_W", 0, UINT_MAX);
|
|
|
|
if (!prop)
|
|
|
|
return -ENOMEM;
|
|
|
|
dev->mode_config.prop_src_w = prop;
|
|
|
|
|
|
|
|
prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
|
|
|
|
"SRC_H", 0, UINT_MAX);
|
|
|
|
if (!prop)
|
|
|
|
return -ENOMEM;
|
|
|
|
dev->mode_config.prop_src_h = prop;
|
|
|
|
|
|
|
|
prop = drm_property_create_signed_range(dev, DRM_MODE_PROP_ATOMIC,
|
|
|
|
"CRTC_X", INT_MIN, INT_MAX);
|
|
|
|
if (!prop)
|
|
|
|
return -ENOMEM;
|
|
|
|
dev->mode_config.prop_crtc_x = prop;
|
|
|
|
|
|
|
|
prop = drm_property_create_signed_range(dev, DRM_MODE_PROP_ATOMIC,
|
|
|
|
"CRTC_Y", INT_MIN, INT_MAX);
|
|
|
|
if (!prop)
|
|
|
|
return -ENOMEM;
|
|
|
|
dev->mode_config.prop_crtc_y = prop;
|
|
|
|
|
|
|
|
prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
|
|
|
|
"CRTC_W", 0, INT_MAX);
|
|
|
|
if (!prop)
|
|
|
|
return -ENOMEM;
|
|
|
|
dev->mode_config.prop_crtc_w = prop;
|
|
|
|
|
|
|
|
prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
|
|
|
|
"CRTC_H", 0, INT_MAX);
|
|
|
|
if (!prop)
|
|
|
|
return -ENOMEM;
|
|
|
|
dev->mode_config.prop_crtc_h = prop;
|
|
|
|
|
|
|
|
prop = drm_property_create_object(dev, DRM_MODE_PROP_ATOMIC,
|
|
|
|
"FB_ID", DRM_MODE_OBJECT_FB);
|
|
|
|
if (!prop)
|
|
|
|
return -ENOMEM;
|
|
|
|
dev->mode_config.prop_fb_id = prop;
|
|
|
|
|
|
|
|
prop = drm_property_create_object(dev, DRM_MODE_PROP_ATOMIC,
|
|
|
|
"CRTC_ID", DRM_MODE_OBJECT_CRTC);
|
|
|
|
if (!prop)
|
|
|
|
return -ENOMEM;
|
|
|
|
dev->mode_config.prop_crtc_id = prop;
|
2014-04-02 08:16:57 +08:00
|
|
|
|
2015-01-22 23:36:21 +08:00
|
|
|
prop = drm_property_create_bool(dev, DRM_MODE_PROP_ATOMIC,
|
|
|
|
"ACTIVE");
|
|
|
|
if (!prop)
|
|
|
|
return -ENOMEM;
|
|
|
|
dev->mode_config.prop_active = prop;
|
|
|
|
|
2015-05-26 02:11:52 +08:00
|
|
|
prop = drm_property_create(dev,
|
|
|
|
DRM_MODE_PROP_ATOMIC | DRM_MODE_PROP_BLOB,
|
|
|
|
"MODE_ID", 0);
|
|
|
|
if (!prop)
|
|
|
|
return -ENOMEM;
|
|
|
|
dev->mode_config.prop_mode_id = prop;
|
|
|
|
|
2016-02-27 01:05:00 +08:00
|
|
|
prop = drm_property_create(dev,
|
|
|
|
DRM_MODE_PROP_BLOB,
|
|
|
|
"DEGAMMA_LUT", 0);
|
|
|
|
if (!prop)
|
|
|
|
return -ENOMEM;
|
|
|
|
dev->mode_config.degamma_lut_property = prop;
|
|
|
|
|
|
|
|
prop = drm_property_create_range(dev,
|
|
|
|
DRM_MODE_PROP_IMMUTABLE,
|
|
|
|
"DEGAMMA_LUT_SIZE", 0, UINT_MAX);
|
|
|
|
if (!prop)
|
|
|
|
return -ENOMEM;
|
|
|
|
dev->mode_config.degamma_lut_size_property = prop;
|
|
|
|
|
|
|
|
prop = drm_property_create(dev,
|
|
|
|
DRM_MODE_PROP_BLOB,
|
|
|
|
"CTM", 0);
|
|
|
|
if (!prop)
|
|
|
|
return -ENOMEM;
|
|
|
|
dev->mode_config.ctm_property = prop;
|
|
|
|
|
|
|
|
prop = drm_property_create(dev,
|
|
|
|
DRM_MODE_PROP_BLOB,
|
|
|
|
"GAMMA_LUT", 0);
|
|
|
|
if (!prop)
|
|
|
|
return -ENOMEM;
|
|
|
|
dev->mode_config.gamma_lut_property = prop;
|
|
|
|
|
|
|
|
prop = drm_property_create_range(dev,
|
|
|
|
DRM_MODE_PROP_IMMUTABLE,
|
|
|
|
"GAMMA_LUT_SIZE", 0, UINT_MAX);
|
|
|
|
if (!prop)
|
|
|
|
return -ENOMEM;
|
|
|
|
dev->mode_config.gamma_lut_size_property = prop;
|
|
|
|
|
2014-04-02 08:16:57 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-11-08 06:05:41 +08: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 17:58:17 +08:00
|
|
|
drm_property_create_enum(dev, 0,
|
2008-11-08 06:05:41 +08:00
|
|
|
"select subconnector",
|
2012-02-06 17:58:17 +08:00
|
|
|
drm_dvi_i_select_enum_list,
|
2008-11-08 06:05:41 +08:00
|
|
|
ARRAY_SIZE(drm_dvi_i_select_enum_list));
|
|
|
|
dev->mode_config.dvi_i_select_subconnector_property = dvi_i_selector;
|
|
|
|
|
2012-02-06 17:58:17 +08:00
|
|
|
dvi_i_subconnector = drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE,
|
2008-11-08 06:05:41 +08:00
|
|
|
"subconnector",
|
2012-02-06 17:58:17 +08:00
|
|
|
drm_dvi_i_subconnector_enum_list,
|
2008-11-08 06:05:41 +08: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.
|
|
|
|
*/
|
2014-10-13 18:45:57 +08:00
|
|
|
int drm_mode_create_tv_properties(struct drm_device *dev,
|
|
|
|
unsigned int num_modes,
|
2015-08-31 20:09:26 +08:00
|
|
|
const char * const modes[])
|
2008-11-08 06:05:41 +08:00
|
|
|
{
|
|
|
|
struct drm_property *tv_selector;
|
|
|
|
struct drm_property *tv_subconnector;
|
2014-10-13 18:45:57 +08:00
|
|
|
unsigned int i;
|
2008-11-08 06:05:41 +08:00
|
|
|
|
|
|
|
if (dev->mode_config.tv_select_subconnector_property)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Basic connector properties
|
|
|
|
*/
|
2012-02-06 17:58:17 +08:00
|
|
|
tv_selector = drm_property_create_enum(dev, 0,
|
2008-11-08 06:05:41 +08:00
|
|
|
"select subconnector",
|
2012-02-06 17:58:17 +08:00
|
|
|
drm_tv_select_enum_list,
|
2008-11-08 06:05:41 +08:00
|
|
|
ARRAY_SIZE(drm_tv_select_enum_list));
|
2015-10-20 00:33:30 +08:00
|
|
|
if (!tv_selector)
|
|
|
|
goto nomem;
|
|
|
|
|
2008-11-08 06:05:41 +08:00
|
|
|
dev->mode_config.tv_select_subconnector_property = tv_selector;
|
|
|
|
|
|
|
|
tv_subconnector =
|
2012-02-06 17:58:17 +08:00
|
|
|
drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE,
|
|
|
|
"subconnector",
|
|
|
|
drm_tv_subconnector_enum_list,
|
2008-11-08 06:05:41 +08:00
|
|
|
ARRAY_SIZE(drm_tv_subconnector_enum_list));
|
2015-10-20 00:33:30 +08:00
|
|
|
if (!tv_subconnector)
|
|
|
|
goto nomem;
|
2008-11-08 06:05:41 +08:00
|
|
|
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 17:58:18 +08:00
|
|
|
drm_property_create_range(dev, 0, "left margin", 0, 100);
|
2015-10-20 00:33:30 +08:00
|
|
|
if (!dev->mode_config.tv_left_margin_property)
|
|
|
|
goto nomem;
|
2008-11-08 06:05:41 +08:00
|
|
|
|
|
|
|
dev->mode_config.tv_right_margin_property =
|
2012-02-06 17:58:18 +08:00
|
|
|
drm_property_create_range(dev, 0, "right margin", 0, 100);
|
2015-10-20 00:33:30 +08:00
|
|
|
if (!dev->mode_config.tv_right_margin_property)
|
|
|
|
goto nomem;
|
2008-11-08 06:05:41 +08:00
|
|
|
|
|
|
|
dev->mode_config.tv_top_margin_property =
|
2012-02-06 17:58:18 +08:00
|
|
|
drm_property_create_range(dev, 0, "top margin", 0, 100);
|
2015-10-20 00:33:30 +08:00
|
|
|
if (!dev->mode_config.tv_top_margin_property)
|
|
|
|
goto nomem;
|
2008-11-08 06:05:41 +08:00
|
|
|
|
|
|
|
dev->mode_config.tv_bottom_margin_property =
|
2012-02-06 17:58:18 +08:00
|
|
|
drm_property_create_range(dev, 0, "bottom margin", 0, 100);
|
2015-10-20 00:33:30 +08:00
|
|
|
if (!dev->mode_config.tv_bottom_margin_property)
|
|
|
|
goto nomem;
|
2008-11-08 06:05:41 +08:00
|
|
|
|
|
|
|
dev->mode_config.tv_mode_property =
|
|
|
|
drm_property_create(dev, DRM_MODE_PROP_ENUM,
|
|
|
|
"mode", num_modes);
|
2015-10-20 00:33:30 +08:00
|
|
|
if (!dev->mode_config.tv_mode_property)
|
|
|
|
goto nomem;
|
|
|
|
|
2008-11-08 06:05:41 +08:00
|
|
|
for (i = 0; i < num_modes; i++)
|
|
|
|
drm_property_add_enum(dev->mode_config.tv_mode_property, i,
|
|
|
|
i, modes[i]);
|
|
|
|
|
2009-08-02 10:19:20 +08:00
|
|
|
dev->mode_config.tv_brightness_property =
|
2012-02-06 17:58:18 +08:00
|
|
|
drm_property_create_range(dev, 0, "brightness", 0, 100);
|
2015-10-20 00:33:30 +08:00
|
|
|
if (!dev->mode_config.tv_brightness_property)
|
|
|
|
goto nomem;
|
2009-08-02 10:19:20 +08:00
|
|
|
|
|
|
|
dev->mode_config.tv_contrast_property =
|
2012-02-06 17:58:18 +08:00
|
|
|
drm_property_create_range(dev, 0, "contrast", 0, 100);
|
2015-10-20 00:33:30 +08:00
|
|
|
if (!dev->mode_config.tv_contrast_property)
|
|
|
|
goto nomem;
|
2009-08-02 10:19:20 +08:00
|
|
|
|
|
|
|
dev->mode_config.tv_flicker_reduction_property =
|
2012-02-06 17:58:18 +08:00
|
|
|
drm_property_create_range(dev, 0, "flicker reduction", 0, 100);
|
2015-10-20 00:33:30 +08:00
|
|
|
if (!dev->mode_config.tv_flicker_reduction_property)
|
|
|
|
goto nomem;
|
2009-08-02 10:19:20 +08:00
|
|
|
|
2009-08-12 08:30:10 +08:00
|
|
|
dev->mode_config.tv_overscan_property =
|
2012-02-06 17:58:18 +08:00
|
|
|
drm_property_create_range(dev, 0, "overscan", 0, 100);
|
2015-10-20 00:33:30 +08:00
|
|
|
if (!dev->mode_config.tv_overscan_property)
|
|
|
|
goto nomem;
|
2009-08-12 08:30:10 +08:00
|
|
|
|
|
|
|
dev->mode_config.tv_saturation_property =
|
2012-02-06 17:58:18 +08:00
|
|
|
drm_property_create_range(dev, 0, "saturation", 0, 100);
|
2015-10-20 00:33:30 +08:00
|
|
|
if (!dev->mode_config.tv_saturation_property)
|
|
|
|
goto nomem;
|
2009-08-12 08:30:10 +08:00
|
|
|
|
|
|
|
dev->mode_config.tv_hue_property =
|
2012-02-06 17:58:18 +08:00
|
|
|
drm_property_create_range(dev, 0, "hue", 0, 100);
|
2015-10-20 00:33:30 +08:00
|
|
|
if (!dev->mode_config.tv_hue_property)
|
|
|
|
goto nomem;
|
2009-08-12 08:30:10 +08:00
|
|
|
|
2008-11-08 06:05:41 +08:00
|
|
|
return 0;
|
2015-10-20 00:33:30 +08:00
|
|
|
nomem:
|
|
|
|
return -ENOMEM;
|
2008-11-08 06:05:41 +08:00
|
|
|
}
|
|
|
|
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 17:58:17 +08:00
|
|
|
drm_property_create_enum(dev, 0, "scaling mode",
|
|
|
|
drm_scaling_mode_enum_list,
|
2008-11-08 06:05:41 +08: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);
|
|
|
|
|
2014-06-11 13:16:48 +08:00
|
|
|
/**
|
|
|
|
* drm_mode_create_aspect_ratio_property - create aspect ratio property
|
|
|
|
* @dev: DRM device
|
|
|
|
*
|
|
|
|
* Called by a driver the first time it's needed, must be attached to desired
|
|
|
|
* connectors.
|
|
|
|
*
|
|
|
|
* Returns:
|
2014-11-20 01:38:09 +08:00
|
|
|
* Zero on success, negative errno on failure.
|
2014-06-11 13:16:48 +08:00
|
|
|
*/
|
|
|
|
int drm_mode_create_aspect_ratio_property(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
if (dev->mode_config.aspect_ratio_property)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
dev->mode_config.aspect_ratio_property =
|
|
|
|
drm_property_create_enum(dev, 0, "aspect ratio",
|
|
|
|
drm_aspect_ratio_enum_list,
|
|
|
|
ARRAY_SIZE(drm_aspect_ratio_enum_list));
|
|
|
|
|
|
|
|
if (dev->mode_config.aspect_ratio_property == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_mode_create_aspect_ratio_property);
|
|
|
|
|
2014-11-10 08:18:15 +08:00
|
|
|
/**
|
|
|
|
* drm_mode_create_suggested_offset_properties - create suggests offset properties
|
|
|
|
* @dev: DRM device
|
|
|
|
*
|
|
|
|
* Create the the suggested x/y offset property for connectors.
|
|
|
|
*/
|
|
|
|
int drm_mode_create_suggested_offset_properties(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
if (dev->mode_config.suggested_x_property && dev->mode_config.suggested_y_property)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
dev->mode_config.suggested_x_property =
|
|
|
|
drm_property_create_range(dev, DRM_MODE_PROP_IMMUTABLE, "suggested X", 0, 0xffffffff);
|
|
|
|
|
|
|
|
dev->mode_config.suggested_y_property =
|
|
|
|
drm_property_create_range(dev, DRM_MODE_PROP_IMMUTABLE, "suggested Y", 0, 0xffffffff);
|
|
|
|
|
|
|
|
if (dev->mode_config.suggested_x_property == NULL ||
|
|
|
|
dev->mode_config.suggested_y_property == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_mode_create_suggested_offset_properties);
|
|
|
|
|
2008-11-08 06:05:41 +08:00
|
|
|
/**
|
|
|
|
* drm_mode_getresources - get graphics configuration
|
2012-12-02 07:09:18 +08:00
|
|
|
* @dev: drm device for the ioctl
|
|
|
|
* @data: data pointer for the ioctl
|
|
|
|
* @file_priv: drm file for the ioctl call
|
2008-11-08 06:05:41 +08: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-11 04:33:02 +08:00
|
|
|
* Returns:
|
2014-11-20 01:38:09 +08:00
|
|
|
* Zero on success, negative errno on failure.
|
2008-11-08 06:05:41 +08:00
|
|
|
*/
|
|
|
|
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;
|
2015-07-10 05:44:36 +08:00
|
|
|
int copied = 0;
|
2008-11-08 06:05:41 +08:00
|
|
|
uint32_t __user *fb_id;
|
|
|
|
uint32_t __user *crtc_id;
|
|
|
|
uint32_t __user *connector_id;
|
|
|
|
uint32_t __user *encoder_id;
|
|
|
|
|
2011-02-08 11:55:21 +08:00
|
|
|
if (!drm_core_check_feature(dev, DRIVER_MODESET))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2008-11-08 06:05:41 +08: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-11 04:19:18 +08:00
|
|
|
mutex_lock(&file_priv->fbs_lock);
|
2008-11-08 06:05:41 +08: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-11 04:19:18 +08: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);
|
|
|
|
|
2014-11-12 15:45:01 +08:00
|
|
|
/* mode_config.mutex protects the connector list against e.g. DP MST
|
|
|
|
* connector hot-adding. CRTC/Plane lists are invariant. */
|
|
|
|
mutex_lock(&dev->mode_config.mutex);
|
2015-07-10 05:44:36 +08:00
|
|
|
drm_for_each_crtc(crtc, dev)
|
|
|
|
crtc_count++;
|
2008-11-08 06:05:41 +08:00
|
|
|
|
2015-07-10 05:44:36 +08:00
|
|
|
drm_for_each_connector(connector, dev)
|
|
|
|
connector_count++;
|
2008-11-08 06:05:41 +08:00
|
|
|
|
2015-07-10 05:44:36 +08:00
|
|
|
drm_for_each_encoder(encoder, dev)
|
|
|
|
encoder_count++;
|
2008-11-08 06:05:41 +08:00
|
|
|
|
|
|
|
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;
|
2015-07-10 05:44:36 +08:00
|
|
|
drm_for_each_crtc(crtc, dev) {
|
|
|
|
if (put_user(crtc->base.id, crtc_id + copied)) {
|
|
|
|
ret = -EFAULT;
|
|
|
|
goto out;
|
2008-11-08 06:05:41 +08:00
|
|
|
}
|
2015-07-10 05:44:36 +08:00
|
|
|
copied++;
|
2008-11-08 06:05:41 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
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;
|
2015-07-10 05:44:36 +08:00
|
|
|
drm_for_each_encoder(encoder, dev) {
|
|
|
|
if (put_user(encoder->base.id, encoder_id +
|
|
|
|
copied)) {
|
|
|
|
ret = -EFAULT;
|
|
|
|
goto out;
|
2008-11-08 06:05:41 +08:00
|
|
|
}
|
2015-07-10 05:44:36 +08:00
|
|
|
copied++;
|
2008-11-08 06:05:41 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
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;
|
2015-07-10 05:44:36 +08:00
|
|
|
drm_for_each_connector(connector, dev) {
|
|
|
|
if (put_user(connector->base.id,
|
|
|
|
connector_id + copied)) {
|
|
|
|
ret = -EFAULT;
|
|
|
|
goto out;
|
2008-11-08 06:05:41 +08:00
|
|
|
}
|
2015-07-10 05:44:36 +08:00
|
|
|
copied++;
|
2008-11-08 06:05:41 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
card_res->count_connectors = connector_count;
|
|
|
|
|
|
|
|
out:
|
2014-11-12 15:45:01 +08:00
|
|
|
mutex_unlock(&dev->mode_config.mutex);
|
2008-11-08 06:05:41 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_mode_getcrtc - get CRTC configuration
|
2012-12-02 07:09:18 +08:00
|
|
|
* @dev: drm device for the ioctl
|
|
|
|
* @data: data pointer for the ioctl
|
|
|
|
* @file_priv: drm file for the ioctl call
|
2008-11-08 06:05:41 +08:00
|
|
|
*
|
|
|
|
* Construct a CRTC configuration structure to return to the user.
|
|
|
|
*
|
|
|
|
* Called by the user via ioctl.
|
|
|
|
*
|
2014-03-11 04:33:02 +08:00
|
|
|
* Returns:
|
2014-11-20 01:38:09 +08:00
|
|
|
* Zero on success, negative errno on failure.
|
2008-11-08 06:05:41 +08: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 11:55:21 +08:00
|
|
|
if (!drm_core_check_feature(dev, DRIVER_MODESET))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2013-10-06 04:36:52 +08:00
|
|
|
crtc = drm_crtc_find(dev, crtc_resp->crtc_id);
|
2014-11-12 15:45:01 +08:00
|
|
|
if (!crtc)
|
|
|
|
return -ENOENT;
|
2008-11-08 06:05:41 +08:00
|
|
|
|
2014-11-12 15:45:01 +08:00
|
|
|
drm_modeset_lock_crtc(crtc, crtc->primary);
|
2008-11-08 06:05:41 +08:00
|
|
|
crtc_resp->gamma_size = crtc->gamma_size;
|
2014-04-02 06:22:40 +08:00
|
|
|
if (crtc->primary->fb)
|
|
|
|
crtc_resp->fb_id = crtc->primary->fb->base.id;
|
2008-11-08 06:05:41 +08:00
|
|
|
else
|
|
|
|
crtc_resp->fb_id = 0;
|
|
|
|
|
2015-02-22 19:24:17 +08:00
|
|
|
if (crtc->state) {
|
|
|
|
crtc_resp->x = crtc->primary->state->src_x >> 16;
|
|
|
|
crtc_resp->y = crtc->primary->state->src_y >> 16;
|
|
|
|
if (crtc->state->enable) {
|
2015-05-22 20:34:48 +08:00
|
|
|
drm_mode_convert_to_umode(&crtc_resp->mode, &crtc->state->mode);
|
2015-02-22 19:24:17 +08:00
|
|
|
crtc_resp->mode_valid = 1;
|
2008-11-08 06:05:41 +08:00
|
|
|
|
2015-02-22 19:24:17 +08:00
|
|
|
} else {
|
|
|
|
crtc_resp->mode_valid = 0;
|
|
|
|
}
|
2008-11-08 06:05:41 +08:00
|
|
|
} else {
|
2015-02-22 19:24:17 +08:00
|
|
|
crtc_resp->x = crtc->x;
|
|
|
|
crtc_resp->y = crtc->y;
|
|
|
|
if (crtc->enabled) {
|
2015-05-22 20:34:48 +08:00
|
|
|
drm_mode_convert_to_umode(&crtc_resp->mode, &crtc->mode);
|
2015-02-22 19:24:17 +08:00
|
|
|
crtc_resp->mode_valid = 1;
|
|
|
|
|
|
|
|
} else {
|
|
|
|
crtc_resp->mode_valid = 0;
|
|
|
|
}
|
2008-11-08 06:05:41 +08:00
|
|
|
}
|
2014-11-12 15:45:01 +08:00
|
|
|
drm_modeset_unlock_crtc(crtc);
|
2008-11-08 06:05:41 +08:00
|
|
|
|
2014-11-12 18:59:47 +08:00
|
|
|
return 0;
|
2008-11-08 06:05:41 +08:00
|
|
|
}
|
|
|
|
|
2013-09-25 23:45:22 +08: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;
|
|
|
|
}
|
|
|
|
|
2014-11-26 06:50:05 +08:00
|
|
|
static struct drm_encoder *drm_connector_get_encoder(struct drm_connector *connector)
|
|
|
|
{
|
|
|
|
/* For atomic drivers only state objects are synchronously updated and
|
|
|
|
* protected by modeset locks, so check those first. */
|
|
|
|
if (connector->state)
|
|
|
|
return connector->state->best_encoder;
|
|
|
|
return connector->encoder;
|
|
|
|
}
|
|
|
|
|
2014-12-19 05:01:49 +08:00
|
|
|
/* helper for getconnector and getproperties ioctls */
|
2014-12-19 05:01:50 +08:00
|
|
|
static int get_properties(struct drm_mode_object *obj, bool atomic,
|
2014-12-19 05:01:49 +08:00
|
|
|
uint32_t __user *prop_ptr, uint64_t __user *prop_values,
|
|
|
|
uint32_t *arg_count_props)
|
|
|
|
{
|
2014-12-19 05:01:50 +08:00
|
|
|
int props_count;
|
|
|
|
int i, ret, copied;
|
|
|
|
|
|
|
|
props_count = obj->properties->count;
|
|
|
|
if (!atomic)
|
|
|
|
props_count -= obj->properties->atomic_count;
|
2014-12-19 05:01:49 +08:00
|
|
|
|
|
|
|
if ((*arg_count_props >= props_count) && props_count) {
|
2014-12-19 05:01:50 +08:00
|
|
|
for (i = 0, copied = 0; copied < props_count; i++) {
|
2014-12-19 05:01:49 +08:00
|
|
|
struct drm_property *prop = obj->properties->properties[i];
|
|
|
|
uint64_t val;
|
|
|
|
|
2014-12-19 05:01:50 +08:00
|
|
|
if ((prop->flags & DRM_MODE_PROP_ATOMIC) && !atomic)
|
|
|
|
continue;
|
|
|
|
|
2014-12-19 05:01:49 +08:00
|
|
|
ret = drm_object_property_get_value(obj, prop, &val);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
if (put_user(prop->base.id, prop_ptr + copied))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
if (put_user(val, prop_values + copied))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
copied++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
*arg_count_props = props_count;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-11-08 06:05:41 +08:00
|
|
|
/**
|
|
|
|
* drm_mode_getconnector - get connector configuration
|
2012-12-02 07:09:18 +08:00
|
|
|
* @dev: drm device for the ioctl
|
|
|
|
* @data: data pointer for the ioctl
|
|
|
|
* @file_priv: drm file for the ioctl call
|
2008-11-08 06:05:41 +08:00
|
|
|
*
|
|
|
|
* Construct a connector configuration structure to return to the user.
|
|
|
|
*
|
|
|
|
* Called by the user via ioctl.
|
|
|
|
*
|
2014-03-11 04:33:02 +08:00
|
|
|
* Returns:
|
2014-11-20 01:38:09 +08:00
|
|
|
* Zero on success, negative errno on failure.
|
2008-11-08 06:05:41 +08:00
|
|
|
*/
|
|
|
|
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;
|
2014-11-26 06:50:05 +08:00
|
|
|
struct drm_encoder *encoder;
|
2008-11-08 06:05:41 +08:00
|
|
|
struct drm_display_mode *mode;
|
|
|
|
int mode_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 *encoder_ptr;
|
|
|
|
|
2011-02-08 11:55:21 +08:00
|
|
|
if (!drm_core_check_feature(dev, DRIVER_MODESET))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2008-11-08 06:05:41 +08:00
|
|
|
memset(&u_mode, 0, sizeof(struct drm_mode_modeinfo));
|
|
|
|
|
2012-12-12 07:35:33 +08:00
|
|
|
mutex_lock(&dev->mode_config.mutex);
|
2008-11-08 06:05:41 +08:00
|
|
|
|
2016-04-27 09:10:09 +08:00
|
|
|
connector = drm_connector_lookup(dev, out_resp->connector_id);
|
2013-10-06 04:36:52 +08:00
|
|
|
if (!connector) {
|
2013-10-17 18:35:00 +08:00
|
|
|
ret = -ENOENT;
|
2015-04-03 15:45:29 +08:00
|
|
|
goto out_unlock;
|
2008-11-08 06:05:41 +08:00
|
|
|
}
|
|
|
|
|
2014-12-10 20:03:38 +08:00
|
|
|
for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++)
|
|
|
|
if (connector->encoder_ids[i] != 0)
|
2008-11-08 06:05:41 +08:00
|
|
|
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 23:45:22 +08:00
|
|
|
if (drm_mode_expose_to_userspace(mode, file_priv))
|
|
|
|
mode_count++;
|
2008-11-08 06:05:41 +08: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;
|
2015-02-22 18:38:36 +08:00
|
|
|
|
|
|
|
drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
|
2014-11-26 06:50:05 +08:00
|
|
|
encoder = drm_connector_get_encoder(connector);
|
|
|
|
if (encoder)
|
|
|
|
out_resp->encoder_id = encoder->base.id;
|
2008-11-08 06:05:41 +08:00
|
|
|
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-20 06:06:42 +08:00
|
|
|
mode_ptr = (struct drm_mode_modeinfo __user *)(unsigned long)out_resp->modes_ptr;
|
2008-11-08 06:05:41 +08:00
|
|
|
list_for_each_entry(mode, &connector->modes, head) {
|
2013-09-25 23:45:22 +08:00
|
|
|
if (!drm_mode_expose_to_userspace(mode, file_priv))
|
|
|
|
continue;
|
|
|
|
|
2015-05-22 20:34:48 +08:00
|
|
|
drm_mode_convert_to_umode(&u_mode, mode);
|
2008-11-08 06:05:41 +08:00
|
|
|
if (copy_to_user(mode_ptr + copied,
|
|
|
|
&u_mode, sizeof(u_mode))) {
|
|
|
|
ret = -EFAULT;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
copied++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
out_resp->count_modes = mode_count;
|
|
|
|
|
2014-12-19 05:01:50 +08:00
|
|
|
ret = get_properties(&connector->base, file_priv->atomic,
|
2014-12-19 05:01:49 +08:00
|
|
|
(uint32_t __user *)(unsigned long)(out_resp->props_ptr),
|
|
|
|
(uint64_t __user *)(unsigned long)(out_resp->prop_values_ptr),
|
|
|
|
&out_resp->count_props);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
2008-11-08 06:05:41 +08:00
|
|
|
|
|
|
|
if ((out_resp->count_encoders >= encoders_count) && encoders_count) {
|
|
|
|
copied = 0;
|
2011-12-20 06:06:42 +08:00
|
|
|
encoder_ptr = (uint32_t __user *)(unsigned long)(out_resp->encoders_ptr);
|
2008-11-08 06:05:41 +08: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:
|
2014-12-19 05:01:48 +08:00
|
|
|
drm_modeset_unlock(&dev->mode_config.connection_mutex);
|
2015-04-03 15:45:29 +08:00
|
|
|
|
2016-04-27 09:10:09 +08:00
|
|
|
drm_connector_unreference(connector);
|
2015-04-03 15:45:29 +08:00
|
|
|
out_unlock:
|
2012-12-12 07:35:33 +08:00
|
|
|
mutex_unlock(&dev->mode_config.mutex);
|
|
|
|
|
2008-11-08 06:05:41 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-11-26 06:50:05 +08:00
|
|
|
static struct drm_crtc *drm_encoder_get_crtc(struct drm_encoder *encoder)
|
|
|
|
{
|
|
|
|
struct drm_connector *connector;
|
|
|
|
struct drm_device *dev = encoder->dev;
|
|
|
|
bool uses_atomic = false;
|
|
|
|
|
|
|
|
/* For atomic drivers only state objects are synchronously updated and
|
|
|
|
* protected by modeset locks, so check those first. */
|
drm: Add modeset object iterators
And roll them out across drm_* files. The point here isn't code
prettification (it helps with that too) but that some of these lists
aren't static any more. And having macros will gives us a convenient
place to put locking checks into.
I didn't add an iterator for props since that's only used by a
list_for_each_entry_safe in the driver teardown code.
Search&replace was done with the below cocci spatch. Note that there's
a bunch more places that didn't match and which would need some manual
changes, but I've intentially left these out for this mostly automated
patch.
iterator name drm_for_each_crtc;
struct drm_crtc *crtc;
struct drm_device *dev;
expression head;
@@
- list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
+ drm_for_each_crtc (crtc, dev) {
...
}
@@
iterator name drm_for_each_encoder;
struct drm_encoder *encoder;
struct drm_device *dev;
expression head;
@@
- list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
+ drm_for_each_encoder (encoder, dev) {
...
}
@@
iterator name drm_for_each_fb;
struct drm_framebuffer *fb;
struct drm_device *dev;
expression head;
@@
- list_for_each_entry(fb, &dev->mode_config.fb_list, head) {
+ drm_for_each_fb (fb, dev) {
...
}
@@
iterator name drm_for_each_connector;
struct drm_connector *connector;
struct drm_device *dev;
expression head;
@@
- list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
+ drm_for_each_connector (connector, dev) {
...
}
Reviewed-by: Maarten Lankhorst <maarten.lankhorst@linux.intel.com>
Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>
2015-07-10 05:44:25 +08:00
|
|
|
drm_for_each_connector(connector, dev) {
|
2014-11-26 06:50:05 +08:00
|
|
|
if (!connector->state)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
uses_atomic = true;
|
|
|
|
|
|
|
|
if (connector->state->best_encoder != encoder)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
return connector->state->crtc;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Don't return stale data (e.g. pending async disable). */
|
|
|
|
if (uses_atomic)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return encoder->crtc;
|
|
|
|
}
|
|
|
|
|
2014-03-11 04:33:02 +08: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:
|
2014-11-20 01:38:09 +08:00
|
|
|
* Zero on success, negative errno on failure.
|
2014-03-11 04:33:02 +08:00
|
|
|
*/
|
2008-11-08 06:05:41 +08: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;
|
2014-11-26 06:50:05 +08:00
|
|
|
struct drm_crtc *crtc;
|
2008-11-08 06:05:41 +08:00
|
|
|
|
2011-02-08 11:55:21 +08:00
|
|
|
if (!drm_core_check_feature(dev, DRIVER_MODESET))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2013-10-06 04:36:52 +08:00
|
|
|
encoder = drm_encoder_find(dev, enc_resp->encoder_id);
|
2014-11-12 15:45:01 +08:00
|
|
|
if (!encoder)
|
|
|
|
return -ENOENT;
|
2008-11-08 06:05:41 +08:00
|
|
|
|
2014-11-12 15:45:01 +08:00
|
|
|
drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
|
2014-11-26 06:50:05 +08:00
|
|
|
crtc = drm_encoder_get_crtc(encoder);
|
|
|
|
if (crtc)
|
|
|
|
enc_resp->crtc_id = crtc->base.id;
|
2008-11-08 06:05:41 +08:00
|
|
|
else
|
|
|
|
enc_resp->crtc_id = 0;
|
2014-11-12 15:45:01 +08:00
|
|
|
drm_modeset_unlock(&dev->mode_config.connection_mutex);
|
|
|
|
|
2008-11-08 06:05:41 +08:00
|
|
|
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;
|
|
|
|
|
2014-11-12 18:59:47 +08:00
|
|
|
return 0;
|
2008-11-08 06:05:41 +08:00
|
|
|
}
|
|
|
|
|
2011-11-15 06:51:27 +08:00
|
|
|
/**
|
2014-03-11 04:33:02 +08:00
|
|
|
* drm_mode_getplane_res - enumerate all plane resources
|
2011-11-15 06:51:27 +08:00
|
|
|
* @dev: DRM device
|
|
|
|
* @data: ioctl data
|
|
|
|
* @file_priv: DRM file info
|
|
|
|
*
|
2014-03-11 04:33:02 +08:00
|
|
|
* Construct a list of plane ids to return to the user.
|
|
|
|
*
|
|
|
|
* Called by the user via ioctl.
|
|
|
|
*
|
|
|
|
* Returns:
|
2014-11-20 01:38:09 +08:00
|
|
|
* Zero on success, negative errno on failure.
|
2011-11-15 06:51:27 +08:00
|
|
|
*/
|
|
|
|
int drm_mode_getplane_res(struct drm_device *dev, void *data,
|
2014-03-11 04:33:02 +08:00
|
|
|
struct drm_file *file_priv)
|
2011-11-15 06:51:27 +08:00
|
|
|
{
|
|
|
|
struct drm_mode_get_plane_res *plane_resp = data;
|
|
|
|
struct drm_mode_config *config;
|
|
|
|
struct drm_plane *plane;
|
|
|
|
uint32_t __user *plane_ptr;
|
2014-11-12 15:45:01 +08:00
|
|
|
int copied = 0;
|
2014-04-02 06:22:42 +08:00
|
|
|
unsigned num_planes;
|
2011-11-15 06:51:27 +08:00
|
|
|
|
|
|
|
if (!drm_core_check_feature(dev, DRIVER_MODESET))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
config = &dev->mode_config;
|
|
|
|
|
2014-04-02 06:22:42 +08:00
|
|
|
if (file_priv->universal_planes)
|
|
|
|
num_planes = config->num_total_plane;
|
|
|
|
else
|
|
|
|
num_planes = config->num_overlay_plane;
|
|
|
|
|
2011-11-15 06:51:27 +08:00
|
|
|
/*
|
|
|
|
* This ioctl is called twice, once to determine how much space is
|
|
|
|
* needed, and the 2nd time to fill it.
|
|
|
|
*/
|
2014-04-02 06:22:42 +08:00
|
|
|
if (num_planes &&
|
|
|
|
(plane_resp->count_planes >= num_planes)) {
|
2011-12-20 06:06:42 +08:00
|
|
|
plane_ptr = (uint32_t __user *)(unsigned long)plane_resp->plane_id_ptr;
|
2011-11-15 06:51:27 +08:00
|
|
|
|
2014-11-12 15:45:01 +08:00
|
|
|
/* Plane lists are invariant, no locking needed. */
|
2015-07-10 05:44:35 +08:00
|
|
|
drm_for_each_plane(plane, dev) {
|
2014-04-02 06:22:42 +08: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-02 06:22:30 +08:00
|
|
|
continue;
|
|
|
|
|
2014-11-12 15:45:01 +08:00
|
|
|
if (put_user(plane->base.id, plane_ptr + copied))
|
|
|
|
return -EFAULT;
|
2011-11-15 06:51:27 +08:00
|
|
|
copied++;
|
|
|
|
}
|
|
|
|
}
|
2014-04-02 06:22:42 +08:00
|
|
|
plane_resp->count_planes = num_planes;
|
2011-11-15 06:51:27 +08:00
|
|
|
|
2014-11-12 15:45:01 +08:00
|
|
|
return 0;
|
2011-11-15 06:51:27 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2014-03-11 04:33:02 +08:00
|
|
|
* drm_mode_getplane - get plane configuration
|
2011-11-15 06:51:27 +08:00
|
|
|
* @dev: DRM device
|
|
|
|
* @data: ioctl data
|
|
|
|
* @file_priv: DRM file info
|
|
|
|
*
|
2014-03-11 04:33:02 +08:00
|
|
|
* Construct a plane configuration structure to return to the user.
|
|
|
|
*
|
|
|
|
* Called by the user via ioctl.
|
|
|
|
*
|
|
|
|
* Returns:
|
2014-11-20 01:38:09 +08:00
|
|
|
* Zero on success, negative errno on failure.
|
2011-11-15 06:51:27 +08:00
|
|
|
*/
|
|
|
|
int drm_mode_getplane(struct drm_device *dev, void *data,
|
2014-03-11 04:33:02 +08:00
|
|
|
struct drm_file *file_priv)
|
2011-11-15 06:51:27 +08:00
|
|
|
{
|
|
|
|
struct drm_mode_get_plane *plane_resp = data;
|
|
|
|
struct drm_plane *plane;
|
|
|
|
uint32_t __user *format_ptr;
|
|
|
|
|
|
|
|
if (!drm_core_check_feature(dev, DRIVER_MODESET))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2013-10-06 04:36:52 +08:00
|
|
|
plane = drm_plane_find(dev, plane_resp->plane_id);
|
2014-11-12 15:45:01 +08:00
|
|
|
if (!plane)
|
|
|
|
return -ENOENT;
|
2011-11-15 06:51:27 +08:00
|
|
|
|
2014-11-12 15:45:01 +08:00
|
|
|
drm_modeset_lock(&plane->mutex, NULL);
|
2011-11-15 06:51:27 +08:00
|
|
|
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;
|
2014-11-12 15:45:01 +08:00
|
|
|
drm_modeset_unlock(&plane->mutex);
|
2011-11-15 06:51:27 +08:00
|
|
|
|
|
|
|
plane_resp->plane_id = plane->base.id;
|
|
|
|
plane_resp->possible_crtcs = plane->possible_crtcs;
|
2013-06-03 21:11:42 +08:00
|
|
|
plane_resp->gamma_size = 0;
|
2011-11-15 06:51:27 +08: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-20 06:06:42 +08:00
|
|
|
format_ptr = (uint32_t __user *)(unsigned long)plane_resp->format_type_ptr;
|
2011-11-15 06:51:27 +08:00
|
|
|
if (copy_to_user(format_ptr,
|
|
|
|
plane->format_types,
|
|
|
|
sizeof(uint32_t) * plane->format_count)) {
|
2014-11-12 15:45:01 +08:00
|
|
|
return -EFAULT;
|
2011-11-15 06:51:27 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
plane_resp->count_format_types = plane->format_count;
|
|
|
|
|
2014-11-12 18:59:47 +08:00
|
|
|
return 0;
|
2011-11-15 06:51:27 +08:00
|
|
|
}
|
|
|
|
|
2015-03-05 08:25:43 +08:00
|
|
|
/**
|
|
|
|
* drm_plane_check_pixel_format - Check if the plane supports the pixel format
|
|
|
|
* @plane: plane to check for format support
|
|
|
|
* @format: the pixel format
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* Zero of @plane has @format in its list of supported pixel formats, -EINVAL
|
|
|
|
* otherwise.
|
|
|
|
*/
|
|
|
|
int drm_plane_check_pixel_format(const struct drm_plane *plane, u32 format)
|
|
|
|
{
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
for (i = 0; i < plane->format_count; i++) {
|
|
|
|
if (format == plane->format_types[i])
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2015-10-16 01:40:00 +08:00
|
|
|
static int check_src_coords(uint32_t src_x, uint32_t src_y,
|
|
|
|
uint32_t src_w, uint32_t src_h,
|
|
|
|
const struct drm_framebuffer *fb)
|
|
|
|
{
|
|
|
|
unsigned int fb_width, fb_height;
|
|
|
|
|
|
|
|
fb_width = fb->width << 16;
|
|
|
|
fb_height = fb->height << 16;
|
|
|
|
|
|
|
|
/* Make sure source coordinates are inside the fb. */
|
|
|
|
if (src_w > fb_width ||
|
|
|
|
src_x > fb_width - src_w ||
|
|
|
|
src_h > fb_height ||
|
|
|
|
src_y > fb_height - src_h) {
|
|
|
|
DRM_DEBUG_KMS("Invalid source coordinates "
|
|
|
|
"%u.%06ux%u.%06u+%u.%06u+%u.%06u\n",
|
|
|
|
src_w >> 16, ((src_w & 0xffff) * 15625) >> 10,
|
|
|
|
src_h >> 16, ((src_h & 0xffff) * 15625) >> 10,
|
|
|
|
src_x >> 16, ((src_x & 0xffff) * 15625) >> 10,
|
|
|
|
src_y >> 16, ((src_y & 0xffff) * 15625) >> 10);
|
|
|
|
return -ENOSPC;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-06-10 23:28:09 +08:00
|
|
|
/*
|
|
|
|
* setplane_internal - setplane handler for internal callers
|
2011-11-15 06:51:27 +08:00
|
|
|
*
|
2014-06-10 23:28:09 +08:00
|
|
|
* Note that we assume an extra reference has already been taken on fb. If the
|
|
|
|
* update fails, this reference will be dropped before return; if it succeeds,
|
|
|
|
* the previous framebuffer (if any) will be unreferenced instead.
|
2014-03-11 04:33:02 +08:00
|
|
|
*
|
2014-06-10 23:28:09 +08:00
|
|
|
* src_{x,y,w,h} are provided in 16.16 fixed point format
|
2011-11-15 06:51:27 +08:00
|
|
|
*/
|
2014-09-12 23:07:32 +08:00
|
|
|
static int __setplane_internal(struct drm_plane *plane,
|
|
|
|
struct drm_crtc *crtc,
|
|
|
|
struct drm_framebuffer *fb,
|
|
|
|
int32_t crtc_x, int32_t crtc_y,
|
|
|
|
uint32_t crtc_w, uint32_t crtc_h,
|
|
|
|
/* src_{x,y,w,h} values are 16.16 fixed point */
|
|
|
|
uint32_t src_x, uint32_t src_y,
|
|
|
|
uint32_t src_w, uint32_t src_h)
|
2011-11-15 06:51:27 +08:00
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
/* No fb means shut it down */
|
2014-06-10 23:28:09 +08:00
|
|
|
if (!fb) {
|
2014-07-27 19:42:42 +08:00
|
|
|
plane->old_fb = plane->fb;
|
2014-04-23 16:24:11 +08:00
|
|
|
ret = plane->funcs->disable_plane(plane);
|
|
|
|
if (!ret) {
|
|
|
|
plane->crtc = NULL;
|
|
|
|
plane->fb = NULL;
|
|
|
|
} else {
|
2014-07-27 19:42:42 +08:00
|
|
|
plane->old_fb = NULL;
|
2014-04-23 16:24:11 +08:00
|
|
|
}
|
2011-11-15 06:51:27 +08:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2014-05-29 23:06:51 +08:00
|
|
|
/* Check whether this plane is usable on this CRTC */
|
|
|
|
if (!(plane->possible_crtcs & drm_crtc_mask(crtc))) {
|
|
|
|
DRM_DEBUG_KMS("Invalid crtc for plane\n");
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2011-12-20 06:06:47 +08:00
|
|
|
/* Check whether this plane supports the fb pixel format. */
|
2015-03-05 08:25:43 +08:00
|
|
|
ret = drm_plane_check_pixel_format(plane, fb->pixel_format);
|
|
|
|
if (ret) {
|
2016-08-15 23:29:55 +08:00
|
|
|
char *format_name = drm_get_format_name(fb->pixel_format);
|
2016-08-15 08:02:38 +08:00
|
|
|
DRM_DEBUG_KMS("Invalid pixel format %s\n", format_name);
|
|
|
|
kfree(format_name);
|
2011-12-20 06:06:47 +08:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2015-04-14 02:06:13 +08:00
|
|
|
/* Give drivers some help against integer overflows */
|
|
|
|
if (crtc_w > INT_MAX ||
|
|
|
|
crtc_x > INT_MAX - (int32_t) crtc_w ||
|
|
|
|
crtc_h > INT_MAX ||
|
|
|
|
crtc_y > INT_MAX - (int32_t) crtc_h) {
|
|
|
|
DRM_DEBUG_KMS("Invalid CRTC coordinates %ux%u+%d+%d\n",
|
|
|
|
crtc_w, crtc_h, crtc_x, crtc_y);
|
2015-10-16 01:39:58 +08:00
|
|
|
ret = -ERANGE;
|
|
|
|
goto out;
|
2015-04-14 02:06:13 +08:00
|
|
|
}
|
|
|
|
|
2015-10-16 01:40:00 +08:00
|
|
|
ret = check_src_coords(src_x, src_y, src_w, src_h, fb);
|
|
|
|
if (ret)
|
2011-12-20 06:06:44 +08:00
|
|
|
goto out;
|
|
|
|
|
2014-07-27 19:42:42 +08:00
|
|
|
plane->old_fb = plane->fb;
|
2011-11-15 06:51:27 +08:00
|
|
|
ret = plane->funcs->update_plane(plane, crtc, fb,
|
2014-06-10 23:28:09 +08:00
|
|
|
crtc_x, crtc_y, crtc_w, crtc_h,
|
|
|
|
src_x, src_y, src_w, src_h);
|
2011-11-15 06:51:27 +08:00
|
|
|
if (!ret) {
|
|
|
|
plane->crtc = crtc;
|
|
|
|
plane->fb = fb;
|
2013-02-16 04:21:37 +08:00
|
|
|
fb = NULL;
|
2014-04-23 23:34:06 +08:00
|
|
|
} else {
|
2014-07-27 19:42:42 +08:00
|
|
|
plane->old_fb = NULL;
|
2011-11-15 06:51:27 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
2012-12-11 07:59:24 +08:00
|
|
|
if (fb)
|
|
|
|
drm_framebuffer_unreference(fb);
|
2014-07-27 19:42:42 +08:00
|
|
|
if (plane->old_fb)
|
|
|
|
drm_framebuffer_unreference(plane->old_fb);
|
|
|
|
plane->old_fb = NULL;
|
2011-11-15 06:51:27 +08:00
|
|
|
|
|
|
|
return ret;
|
2014-09-12 23:07:32 +08:00
|
|
|
}
|
2014-06-10 23:28:09 +08:00
|
|
|
|
2014-09-12 23:07:32 +08:00
|
|
|
static int setplane_internal(struct drm_plane *plane,
|
|
|
|
struct drm_crtc *crtc,
|
|
|
|
struct drm_framebuffer *fb,
|
|
|
|
int32_t crtc_x, int32_t crtc_y,
|
|
|
|
uint32_t crtc_w, uint32_t crtc_h,
|
|
|
|
/* src_{x,y,w,h} values are 16.16 fixed point */
|
|
|
|
uint32_t src_x, uint32_t src_y,
|
|
|
|
uint32_t src_w, uint32_t src_h)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
drm_modeset_lock_all(plane->dev);
|
|
|
|
ret = __setplane_internal(plane, crtc, fb,
|
|
|
|
crtc_x, crtc_y, crtc_w, crtc_h,
|
|
|
|
src_x, src_y, src_w, src_h);
|
|
|
|
drm_modeset_unlock_all(plane->dev);
|
|
|
|
|
|
|
|
return ret;
|
2014-06-10 23:28:09 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_mode_setplane - configure a plane's configuration
|
|
|
|
* @dev: DRM device
|
|
|
|
* @data: ioctl data*
|
|
|
|
* @file_priv: DRM file info
|
|
|
|
*
|
|
|
|
* Set plane configuration, including placement, fb, scaling, and other factors.
|
|
|
|
* Or pass a NULL fb to disable (planes may be disabled without providing a
|
|
|
|
* valid crtc).
|
|
|
|
*
|
|
|
|
* Returns:
|
2014-11-20 01:38:09 +08:00
|
|
|
* Zero on success, negative errno on failure.
|
2014-06-10 23:28:09 +08:00
|
|
|
*/
|
|
|
|
int drm_mode_setplane(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv)
|
|
|
|
{
|
|
|
|
struct drm_mode_set_plane *plane_req = data;
|
|
|
|
struct drm_plane *plane;
|
|
|
|
struct drm_crtc *crtc = NULL;
|
|
|
|
struct drm_framebuffer *fb = NULL;
|
|
|
|
|
|
|
|
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.
|
|
|
|
*/
|
2014-11-26 09:33:11 +08:00
|
|
|
plane = drm_plane_find(dev, plane_req->plane_id);
|
|
|
|
if (!plane) {
|
2014-06-10 23:28:09 +08:00
|
|
|
DRM_DEBUG_KMS("Unknown plane ID %d\n",
|
|
|
|
plane_req->plane_id);
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (plane_req->fb_id) {
|
|
|
|
fb = drm_framebuffer_lookup(dev, plane_req->fb_id);
|
|
|
|
if (!fb) {
|
|
|
|
DRM_DEBUG_KMS("Unknown framebuffer ID %d\n",
|
|
|
|
plane_req->fb_id);
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
|
2014-11-26 09:33:11 +08:00
|
|
|
crtc = drm_crtc_find(dev, plane_req->crtc_id);
|
|
|
|
if (!crtc) {
|
2014-06-10 23:28:09 +08:00
|
|
|
DRM_DEBUG_KMS("Unknown crtc ID %d\n",
|
|
|
|
plane_req->crtc_id);
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-06-10 23:28:10 +08:00
|
|
|
/*
|
|
|
|
* setplane_internal will take care of deref'ing either the old or new
|
|
|
|
* framebuffer depending on success.
|
|
|
|
*/
|
2014-06-13 22:22:28 +08:00
|
|
|
return setplane_internal(plane, crtc, fb,
|
2014-06-10 23:28:09 +08:00
|
|
|
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);
|
2011-11-15 06:51:27 +08:00
|
|
|
}
|
|
|
|
|
2012-12-11 20:47:23 +08: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-12-10 20:03:34 +08:00
|
|
|
*
|
2014-03-11 04:33:02 +08:00
|
|
|
* Returns:
|
2014-11-20 01:38:09 +08:00
|
|
|
* Zero on success, negative errno on failure.
|
2012-12-11 20:47:23 +08:00
|
|
|
*/
|
|
|
|
int drm_mode_set_config_internal(struct drm_mode_set *set)
|
|
|
|
{
|
|
|
|
struct drm_crtc *crtc = set->crtc;
|
2013-06-15 06:13:16 +08:00
|
|
|
struct drm_framebuffer *fb;
|
|
|
|
struct drm_crtc *tmp;
|
2012-12-11 08:07:12 +08:00
|
|
|
int ret;
|
|
|
|
|
2013-06-15 06:13:16 +08: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 05:44:35 +08:00
|
|
|
drm_for_each_crtc(tmp, crtc->dev)
|
2014-07-27 19:42:42 +08:00
|
|
|
tmp->primary->old_fb = tmp->primary->fb;
|
2013-06-15 06:13:16 +08:00
|
|
|
|
2012-12-11 08:07:12 +08:00
|
|
|
fb = set->fb;
|
2012-12-11 20:47:23 +08:00
|
|
|
|
2012-12-11 08:07:12 +08:00
|
|
|
ret = crtc->funcs->set_config(set);
|
|
|
|
if (ret == 0) {
|
2014-04-02 06:22:38 +08:00
|
|
|
crtc->primary->crtc = crtc;
|
2014-04-23 23:34:06 +08:00
|
|
|
crtc->primary->fb = fb;
|
2013-06-15 06:13:16 +08:00
|
|
|
}
|
2013-06-15 06:13:15 +08:00
|
|
|
|
2015-07-10 05:44:35 +08:00
|
|
|
drm_for_each_crtc(tmp, crtc->dev) {
|
2014-04-02 06:22:40 +08:00
|
|
|
if (tmp->primary->fb)
|
|
|
|
drm_framebuffer_reference(tmp->primary->fb);
|
2014-07-27 19:42:42 +08:00
|
|
|
if (tmp->primary->old_fb)
|
|
|
|
drm_framebuffer_unreference(tmp->primary->old_fb);
|
|
|
|
tmp->primary->old_fb = NULL;
|
2012-12-11 08:07:12 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
2012-12-11 20:47:23 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_mode_set_config_internal);
|
|
|
|
|
2014-12-02 07:40:09 +08:00
|
|
|
/**
|
|
|
|
* drm_crtc_get_hv_timing - Fetches hdisplay/vdisplay for given mode
|
|
|
|
* @mode: mode to query
|
|
|
|
* @hdisplay: hdisplay value to fill in
|
|
|
|
* @vdisplay: vdisplay value to fill in
|
|
|
|
*
|
|
|
|
* The vdisplay value will be doubled if the specified mode is a stereo mode of
|
|
|
|
* the appropriate layout.
|
|
|
|
*/
|
|
|
|
void drm_crtc_get_hv_timing(const struct drm_display_mode *mode,
|
|
|
|
int *hdisplay, int *vdisplay)
|
|
|
|
{
|
|
|
|
struct drm_display_mode adjusted;
|
|
|
|
|
|
|
|
drm_mode_copy(&adjusted, mode);
|
|
|
|
drm_mode_set_crtcinfo(&adjusted, CRTC_STEREO_DOUBLE_ONLY);
|
|
|
|
*hdisplay = adjusted.crtc_hdisplay;
|
|
|
|
*vdisplay = adjusted.crtc_vdisplay;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_crtc_get_hv_timing);
|
|
|
|
|
2014-04-02 06:22:34 +08: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 23:45:30 +08:00
|
|
|
*/
|
2014-04-02 06:22:34 +08: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 23:45:30 +08:00
|
|
|
|
|
|
|
{
|
|
|
|
int hdisplay, vdisplay;
|
|
|
|
|
2014-12-02 07:40:09 +08:00
|
|
|
drm_crtc_get_hv_timing(mode, &hdisplay, &vdisplay);
|
2013-09-25 23:45:31 +08:00
|
|
|
|
2015-10-16 23:38:39 +08:00
|
|
|
if (crtc->state &&
|
2016-07-29 13:50:05 +08:00
|
|
|
crtc->primary->state->rotation & (DRM_ROTATE_90 |
|
|
|
|
DRM_ROTATE_270))
|
2013-09-25 23:45:30 +08:00
|
|
|
swap(hdisplay, vdisplay);
|
|
|
|
|
2015-10-16 01:40:00 +08:00
|
|
|
return check_src_coords(x << 16, y << 16,
|
|
|
|
hdisplay << 16, vdisplay << 16, fb);
|
2013-09-25 23:45:30 +08:00
|
|
|
}
|
2014-04-02 06:22:34 +08:00
|
|
|
EXPORT_SYMBOL(drm_crtc_check_viewport);
|
2013-09-25 23:45:30 +08:00
|
|
|
|
2008-11-08 06:05:41 +08:00
|
|
|
/**
|
|
|
|
* drm_mode_setcrtc - set CRTC configuration
|
2012-12-02 07:09:18 +08:00
|
|
|
* @dev: drm device for the ioctl
|
|
|
|
* @data: data pointer for the ioctl
|
|
|
|
* @file_priv: drm file for the ioctl call
|
2008-11-08 06:05:41 +08:00
|
|
|
*
|
|
|
|
* Build a new CRTC configuration based on user request.
|
|
|
|
*
|
|
|
|
* Called by the user via ioctl.
|
|
|
|
*
|
2014-03-11 04:33:02 +08:00
|
|
|
* Returns:
|
2014-11-20 01:38:09 +08:00
|
|
|
* Zero on success, negative errno on failure.
|
2008-11-08 06:05:41 +08: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 18:35:38 +08:00
|
|
|
struct drm_crtc *crtc;
|
2008-11-08 06:05:41 +08: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 19:27:21 +08:00
|
|
|
int ret;
|
2008-11-08 06:05:41 +08:00
|
|
|
int i;
|
|
|
|
|
2011-02-08 11:55:21 +08:00
|
|
|
if (!drm_core_check_feature(dev, DRIVER_MODESET))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2015-07-07 17:08:35 +08: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 18:35:41 +08:00
|
|
|
return -ERANGE;
|
|
|
|
|
2012-12-02 07:28:11 +08:00
|
|
|
drm_modeset_lock_all(dev);
|
2013-10-06 04:36:52 +08:00
|
|
|
crtc = drm_crtc_find(dev, crtc_req->crtc_id);
|
|
|
|
if (!crtc) {
|
2009-07-20 13:48:07 +08:00
|
|
|
DRM_DEBUG_KMS("Unknown CRTC ID %d\n", crtc_req->crtc_id);
|
2013-10-17 18:35:00 +08:00
|
|
|
ret = -ENOENT;
|
2008-11-08 06:05:41 +08:00
|
|
|
goto out;
|
|
|
|
}
|
2015-12-09 00:41:53 +08:00
|
|
|
DRM_DEBUG_KMS("[CRTC:%d:%s]\n", crtc->base.id, crtc->name);
|
2008-11-08 06:05:41 +08: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 06:22:40 +08:00
|
|
|
if (!crtc->primary->fb) {
|
2012-03-13 18:35:38 +08:00
|
|
|
DRM_DEBUG_KMS("CRTC doesn't have current FB\n");
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
2008-11-08 06:05:41 +08:00
|
|
|
}
|
2014-04-02 06:22:40 +08:00
|
|
|
fb = crtc->primary->fb;
|
2012-12-11 08:07:12 +08:00
|
|
|
/* Make refcounting symmetric with the lookup path. */
|
|
|
|
drm_framebuffer_reference(fb);
|
2008-11-08 06:05:41 +08:00
|
|
|
} else {
|
2012-12-03 04:53:40 +08:00
|
|
|
fb = drm_framebuffer_lookup(dev, crtc_req->fb_id);
|
|
|
|
if (!fb) {
|
2009-07-20 13:48:07 +08:00
|
|
|
DRM_DEBUG_KMS("Unknown FB ID%d\n",
|
|
|
|
crtc_req->fb_id);
|
2013-10-17 18:35:01 +08:00
|
|
|
ret = -ENOENT;
|
2008-11-08 06:05:41 +08:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
mode = drm_mode_create(dev);
|
2012-03-13 18:35:43 +08:00
|
|
|
if (!mode) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2015-05-22 20:34:48 +08:00
|
|
|
ret = drm_mode_convert_umode(mode, &crtc_req->mode);
|
2012-03-13 18:35:44 +08:00
|
|
|
if (ret) {
|
|
|
|
DRM_DEBUG_KMS("Invalid mode\n");
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2015-03-09 16:41:07 +08: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,
|
|
|
|
fb->pixel_format);
|
|
|
|
if (ret) {
|
2016-08-15 23:29:55 +08:00
|
|
|
char *format_name = drm_get_format_name(fb->pixel_format);
|
2016-08-15 08:02:38 +08:00
|
|
|
DRM_DEBUG_KMS("Invalid pixel format %s\n", format_name);
|
|
|
|
kfree(format_name);
|
2015-03-09 16:41:07 +08:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-09-25 23:45:30 +08:00
|
|
|
ret = drm_crtc_check_viewport(crtc, crtc_req->x, crtc_req->y,
|
|
|
|
mode, fb);
|
|
|
|
if (ret)
|
2012-03-13 18:35:45 +08:00
|
|
|
goto out;
|
2013-09-25 23:45:30 +08:00
|
|
|
|
2008-11-08 06:05:41 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (crtc_req->count_connectors == 0 && mode) {
|
2009-07-20 13:48:07 +08:00
|
|
|
DRM_DEBUG_KMS("Count connectors is 0 but mode set\n");
|
2008-11-08 06:05:41 +08:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2009-08-03 20:43:58 +08:00
|
|
|
if (crtc_req->count_connectors > 0 && (!mode || !fb)) {
|
2009-07-20 13:48:07 +08:00
|
|
|
DRM_DEBUG_KMS("Count connectors is %d but no mode or fb set\n",
|
2008-11-08 06:05:41 +08: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 20:03:36 +08:00
|
|
|
connector_set = kmalloc_array(crtc_req->count_connectors,
|
|
|
|
sizeof(struct drm_connector *),
|
|
|
|
GFP_KERNEL);
|
2008-11-08 06:05:41 +08:00
|
|
|
if (!connector_set) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < crtc_req->count_connectors; i++) {
|
2016-04-27 09:10:09 +08:00
|
|
|
connector_set[i] = NULL;
|
2011-12-20 06:06:42 +08:00
|
|
|
set_connectors_ptr = (uint32_t __user *)(unsigned long)crtc_req->set_connectors_ptr;
|
2008-11-08 06:05:41 +08:00
|
|
|
if (get_user(out_id, &set_connectors_ptr[i])) {
|
|
|
|
ret = -EFAULT;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2016-04-27 09:10:09 +08:00
|
|
|
connector = drm_connector_lookup(dev, out_id);
|
2013-10-06 04:36:52 +08:00
|
|
|
if (!connector) {
|
2009-07-20 13:48:07 +08:00
|
|
|
DRM_DEBUG_KMS("Connector id %d unknown\n",
|
|
|
|
out_id);
|
2013-10-17 18:35:00 +08:00
|
|
|
ret = -ENOENT;
|
2008-11-08 06:05:41 +08:00
|
|
|
goto out;
|
|
|
|
}
|
2010-07-16 03:43:25 +08:00
|
|
|
DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n",
|
|
|
|
connector->base.id,
|
2014-06-03 19:56:20 +08:00
|
|
|
connector->name);
|
2008-11-08 06:05:41 +08: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 11:11:23 +08:00
|
|
|
set.fb = fb;
|
2012-12-11 20:47:23 +08:00
|
|
|
ret = drm_mode_set_config_internal(&set);
|
2008-11-08 06:05:41 +08:00
|
|
|
|
|
|
|
out:
|
2012-12-11 08:07:12 +08:00
|
|
|
if (fb)
|
|
|
|
drm_framebuffer_unreference(fb);
|
|
|
|
|
2016-04-27 09:10:09 +08:00
|
|
|
if (connector_set) {
|
|
|
|
for (i = 0; i < crtc_req->count_connectors; i++) {
|
|
|
|
if (connector_set[i])
|
|
|
|
drm_connector_unreference(connector_set[i]);
|
|
|
|
}
|
|
|
|
}
|
2008-11-08 06:05:41 +08:00
|
|
|
kfree(connector_set);
|
2012-03-13 18:35:43 +08:00
|
|
|
drm_mode_destroy(dev, mode);
|
2012-12-02 07:28:11 +08:00
|
|
|
drm_modeset_unlock_all(dev);
|
2008-11-08 06:05:41 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-06-10 23:28:10 +08:00
|
|
|
/**
|
|
|
|
* drm_mode_cursor_universal - translate legacy cursor ioctl call into a
|
|
|
|
* universal plane handler call
|
|
|
|
* @crtc: crtc to update cursor for
|
|
|
|
* @req: data pointer for the ioctl
|
|
|
|
* @file_priv: drm file for the ioctl call
|
|
|
|
*
|
|
|
|
* Legacy cursor ioctl's work directly with driver buffer handles. To
|
|
|
|
* translate legacy ioctl calls into universal plane handler calls, we need to
|
|
|
|
* wrap the native buffer handle in a drm_framebuffer.
|
|
|
|
*
|
|
|
|
* Note that we assume any handle passed to the legacy ioctls was a 32-bit ARGB
|
|
|
|
* buffer with a pitch of 4*width; the universal plane interface should be used
|
|
|
|
* directly in cases where the hardware can support other buffer settings and
|
|
|
|
* userspace wants to make use of these capabilities.
|
|
|
|
*
|
|
|
|
* Returns:
|
2014-11-20 01:38:09 +08:00
|
|
|
* Zero on success, negative errno on failure.
|
2014-06-10 23:28:10 +08:00
|
|
|
*/
|
|
|
|
static int drm_mode_cursor_universal(struct drm_crtc *crtc,
|
|
|
|
struct drm_mode_cursor2 *req,
|
|
|
|
struct drm_file *file_priv)
|
|
|
|
{
|
|
|
|
struct drm_device *dev = crtc->dev;
|
|
|
|
struct drm_framebuffer *fb = NULL;
|
|
|
|
struct drm_mode_fb_cmd2 fbreq = {
|
|
|
|
.width = req->width,
|
|
|
|
.height = req->height,
|
|
|
|
.pixel_format = DRM_FORMAT_ARGB8888,
|
|
|
|
.pitches = { req->width * 4 },
|
|
|
|
.handles = { req->handle },
|
|
|
|
};
|
|
|
|
int32_t crtc_x, crtc_y;
|
|
|
|
uint32_t crtc_w = 0, crtc_h = 0;
|
|
|
|
uint32_t src_w = 0, src_h = 0;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
BUG_ON(!crtc->cursor);
|
2014-09-12 23:07:32 +08:00
|
|
|
WARN_ON(crtc->cursor->crtc != crtc && crtc->cursor->crtc != NULL);
|
2014-06-10 23:28:10 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Obtain fb we'll be using (either new or existing) and take an extra
|
|
|
|
* reference to it if fb != null. setplane will take care of dropping
|
|
|
|
* the reference if the plane update fails.
|
|
|
|
*/
|
|
|
|
if (req->flags & DRM_MODE_CURSOR_BO) {
|
|
|
|
if (req->handle) {
|
2016-08-15 22:07:02 +08:00
|
|
|
fb = drm_internal_framebuffer_create(dev, &fbreq, file_priv);
|
2014-06-10 23:28:10 +08:00
|
|
|
if (IS_ERR(fb)) {
|
|
|
|
DRM_DEBUG_KMS("failed to wrap cursor buffer in drm framebuffer\n");
|
|
|
|
return PTR_ERR(fb);
|
|
|
|
}
|
2016-05-31 14:54:52 +08:00
|
|
|
fb->hot_x = req->hot_x;
|
|
|
|
fb->hot_y = req->hot_y;
|
2014-06-10 23:28:10 +08:00
|
|
|
} else {
|
|
|
|
fb = NULL;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
fb = crtc->cursor->fb;
|
|
|
|
if (fb)
|
|
|
|
drm_framebuffer_reference(fb);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (req->flags & DRM_MODE_CURSOR_MOVE) {
|
|
|
|
crtc_x = req->x;
|
|
|
|
crtc_y = req->y;
|
|
|
|
} else {
|
|
|
|
crtc_x = crtc->cursor_x;
|
|
|
|
crtc_y = crtc->cursor_y;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (fb) {
|
|
|
|
crtc_w = fb->width;
|
|
|
|
crtc_h = fb->height;
|
|
|
|
src_w = fb->width << 16;
|
|
|
|
src_h = fb->height << 16;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* setplane_internal will take care of deref'ing either the old or new
|
|
|
|
* framebuffer depending on success.
|
|
|
|
*/
|
2014-09-12 23:07:32 +08:00
|
|
|
ret = __setplane_internal(crtc->cursor, crtc, fb,
|
2014-06-10 23:28:10 +08:00
|
|
|
crtc_x, crtc_y, crtc_w, crtc_h,
|
|
|
|
0, 0, src_w, src_h);
|
|
|
|
|
|
|
|
/* Update successful; save new cursor position, if necessary */
|
|
|
|
if (ret == 0 && req->flags & DRM_MODE_CURSOR_MOVE) {
|
|
|
|
crtc->cursor_x = req->x;
|
|
|
|
crtc->cursor_y = req->y;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2013-06-20 09:48:52 +08:00
|
|
|
static int drm_mode_cursor_common(struct drm_device *dev,
|
|
|
|
struct drm_mode_cursor2 *req,
|
|
|
|
struct drm_file *file_priv)
|
2008-11-08 06:05:41 +08:00
|
|
|
{
|
|
|
|
struct drm_crtc *crtc;
|
|
|
|
int ret = 0;
|
|
|
|
|
2011-02-08 11:55:21 +08:00
|
|
|
if (!drm_core_check_feature(dev, DRIVER_MODESET))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2012-08-16 16:29:03 +08:00
|
|
|
if (!req->flags || (~DRM_MODE_CURSOR_FLAGS & req->flags))
|
2008-11-08 06:05:41 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
2013-10-06 04:36:52 +08:00
|
|
|
crtc = drm_crtc_find(dev, req->crtc_id);
|
|
|
|
if (!crtc) {
|
2009-07-20 13:48:07 +08:00
|
|
|
DRM_DEBUG_KMS("Unknown CRTC ID %d\n", req->crtc_id);
|
2013-10-17 18:35:00 +08:00
|
|
|
return -ENOENT;
|
2008-11-08 06:05:41 +08:00
|
|
|
}
|
|
|
|
|
2014-06-10 23:28:10 +08:00
|
|
|
/*
|
|
|
|
* If this crtc has a universal cursor plane, call that plane's update
|
|
|
|
* handler rather than using legacy cursor handlers.
|
|
|
|
*/
|
2014-11-11 17:12:00 +08:00
|
|
|
drm_modeset_lock_crtc(crtc, crtc->cursor);
|
2014-09-12 23:07:32 +08:00
|
|
|
if (crtc->cursor) {
|
|
|
|
ret = drm_mode_cursor_universal(crtc, req, file_priv);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2008-11-08 06:05:41 +08:00
|
|
|
if (req->flags & DRM_MODE_CURSOR_BO) {
|
2013-06-20 09:48:52 +08:00
|
|
|
if (!crtc->funcs->cursor_set && !crtc->funcs->cursor_set2) {
|
2008-11-08 06:05:41 +08:00
|
|
|
ret = -ENXIO;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
/* Turns off the cursor if handle is 0 */
|
2013-06-20 09:48:52 +08: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-08 06:05:41 +08: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:
|
2014-07-26 00:07:40 +08:00
|
|
|
drm_modeset_unlock_crtc(crtc);
|
2012-12-02 22:24:10 +08:00
|
|
|
|
2008-11-08 06:05:41 +08:00
|
|
|
return ret;
|
2013-06-20 09:48:52 +08:00
|
|
|
|
|
|
|
}
|
2014-03-11 04:33:02 +08: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:
|
2014-11-20 01:38:09 +08:00
|
|
|
* Zero on success, negative errno on failure.
|
2014-03-11 04:33:02 +08:00
|
|
|
*/
|
2013-06-20 09:48:52 +08:00
|
|
|
int drm_mode_cursor_ioctl(struct drm_device *dev,
|
2014-03-11 04:33:02 +08:00
|
|
|
void *data, struct drm_file *file_priv)
|
2013-06-20 09:48:52 +08: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-11 04:33:02 +08: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:
|
2014-11-20 01:38:09 +08:00
|
|
|
* Zero on success, negative errno on failure.
|
2014-03-11 04:33:02 +08:00
|
|
|
*/
|
2013-06-20 09:48:52 +08:00
|
|
|
int drm_mode_cursor2_ioctl(struct drm_device *dev,
|
|
|
|
void *data, struct drm_file *file_priv)
|
|
|
|
{
|
|
|
|
struct drm_mode_cursor2 *req = data;
|
2014-12-10 20:03:34 +08:00
|
|
|
|
2013-06-20 09:48:52 +08:00
|
|
|
return drm_mode_cursor_common(dev, req, file_priv);
|
2008-11-08 06:05:41 +08:00
|
|
|
}
|
|
|
|
|
2014-03-11 04:33:02 +08: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-15 06:51:28 +08:00
|
|
|
uint32_t drm_mode_legacy_fb_format(uint32_t bpp, uint32_t depth)
|
|
|
|
{
|
|
|
|
uint32_t fmt;
|
|
|
|
|
|
|
|
switch (bpp) {
|
|
|
|
case 8:
|
2013-02-01 01:43:38 +08:00
|
|
|
fmt = DRM_FORMAT_C8;
|
2011-11-15 06:51:28 +08:00
|
|
|
break;
|
|
|
|
case 16:
|
|
|
|
if (depth == 15)
|
2011-11-18 00:05:13 +08:00
|
|
|
fmt = DRM_FORMAT_XRGB1555;
|
2011-11-15 06:51:28 +08:00
|
|
|
else
|
2011-11-18 00:05:13 +08:00
|
|
|
fmt = DRM_FORMAT_RGB565;
|
2011-11-15 06:51:28 +08:00
|
|
|
break;
|
|
|
|
case 24:
|
2011-11-18 00:05:13 +08:00
|
|
|
fmt = DRM_FORMAT_RGB888;
|
2011-11-15 06:51:28 +08:00
|
|
|
break;
|
|
|
|
case 32:
|
|
|
|
if (depth == 24)
|
2011-11-18 00:05:13 +08:00
|
|
|
fmt = DRM_FORMAT_XRGB8888;
|
2011-11-15 06:51:28 +08:00
|
|
|
else if (depth == 30)
|
2011-11-18 00:05:13 +08:00
|
|
|
fmt = DRM_FORMAT_XRGB2101010;
|
2011-11-15 06:51:28 +08:00
|
|
|
else
|
2011-11-18 00:05:13 +08:00
|
|
|
fmt = DRM_FORMAT_ARGB8888;
|
2011-11-15 06:51:28 +08:00
|
|
|
break;
|
|
|
|
default:
|
2011-11-18 00:05:13 +08:00
|
|
|
DRM_ERROR("bad bpp, assuming x8r8g8b8 pixel format\n");
|
|
|
|
fmt = DRM_FORMAT_XRGB8888;
|
2011-11-15 06:51:28 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return fmt;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_mode_legacy_fb_format);
|
|
|
|
|
2016-06-21 16:54:13 +08:00
|
|
|
static bool drm_property_type_valid(struct drm_property *property)
|
|
|
|
{
|
|
|
|
if (property->flags & DRM_MODE_PROP_EXTENDED_TYPE)
|
|
|
|
return !(property->flags & DRM_MODE_PROP_LEGACY_TYPE);
|
|
|
|
return !!(property->flags & DRM_MODE_PROP_LEGACY_TYPE);
|
|
|
|
}
|
|
|
|
|
2014-03-11 04:33:02 +08: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.
|
|
|
|
*
|
2014-10-31 22:39:11 +08:00
|
|
|
* Note that the DRM core keeps a per-device list of properties and that, if
|
|
|
|
* drm_mode_config_cleanup() is called, it will destroy all properties created
|
|
|
|
* by the driver.
|
|
|
|
*
|
2014-03-11 04:33:02 +08:00
|
|
|
* Returns:
|
|
|
|
* A pointer to the newly created property on success, NULL on failure.
|
|
|
|
*/
|
2008-11-08 06:05:41 +08: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 18:35:48 +08:00
|
|
|
int ret;
|
2008-11-08 06:05:41 +08:00
|
|
|
|
|
|
|
property = kzalloc(sizeof(struct drm_property), GFP_KERNEL);
|
|
|
|
if (!property)
|
|
|
|
return NULL;
|
|
|
|
|
2014-05-30 23:37:03 +08:00
|
|
|
property->dev = dev;
|
|
|
|
|
2008-11-08 06:05:41 +08:00
|
|
|
if (num_values) {
|
2014-12-10 20:03:35 +08:00
|
|
|
property->values = kcalloc(num_values, sizeof(uint64_t),
|
|
|
|
GFP_KERNEL);
|
2008-11-08 06:05:41 +08:00
|
|
|
if (!property->values)
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2012-03-13 18:35:48 +08:00
|
|
|
ret = drm_mode_object_get(dev, &property->base, DRM_MODE_OBJECT_PROPERTY);
|
|
|
|
if (ret)
|
|
|
|
goto fail;
|
|
|
|
|
2008-11-08 06:05:41 +08:00
|
|
|
property->flags = flags;
|
|
|
|
property->num_values = num_values;
|
2014-11-20 01:38:10 +08:00
|
|
|
INIT_LIST_HEAD(&property->enum_list);
|
2008-11-08 06:05:41 +08:00
|
|
|
|
2011-11-11 03:55:40 +08:00
|
|
|
if (name) {
|
2008-11-08 06:05:41 +08:00
|
|
|
strncpy(property->name, name, DRM_PROP_NAME_LEN);
|
2011-11-11 03:55:40 +08:00
|
|
|
property->name[DRM_PROP_NAME_LEN-1] = '\0';
|
|
|
|
}
|
2008-11-08 06:05:41 +08:00
|
|
|
|
|
|
|
list_add_tail(&property->head, &dev->mode_config.property_list);
|
2014-05-30 23:34:01 +08:00
|
|
|
|
|
|
|
WARN_ON(!drm_property_type_valid(property));
|
|
|
|
|
2008-11-08 06:05:41 +08:00
|
|
|
return property;
|
|
|
|
fail:
|
2012-03-13 18:35:48 +08:00
|
|
|
kfree(property->values);
|
2008-11-08 06:05:41 +08:00
|
|
|
kfree(property);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_property_create);
|
|
|
|
|
2014-03-11 04:33:02 +08:00
|
|
|
/**
|
2014-06-27 03:37:20 +08:00
|
|
|
* drm_property_create_enum - create a new enumeration property type
|
2014-03-11 04:33:02 +08:00
|
|
|
* @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 17:58:17 +08: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-11 04:33:02 +08:00
|
|
|
/**
|
2014-06-27 03:37:20 +08:00
|
|
|
* drm_property_create_bitmask - create a new bitmask property type
|
2014-03-11 04:33:02 +08:00
|
|
|
* @dev: drm device
|
|
|
|
* @flags: flags specifying the property type
|
|
|
|
* @name: name of the property
|
|
|
|
* @props: enumeration lists with property bitflags
|
2014-07-30 20:23:44 +08:00
|
|
|
* @num_props: size of the @props array
|
|
|
|
* @supported_bits: bitmask of all supported enumeration values
|
2014-03-11 04:33:02 +08:00
|
|
|
*
|
2014-07-30 20:23:44 +08:00
|
|
|
* This creates a new bitmask drm property which can then be attached to a drm
|
2014-03-11 04:33:02 +08:00
|
|
|
* 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 16:23:26 +08:00
|
|
|
struct drm_property *drm_property_create_bitmask(struct drm_device *dev,
|
|
|
|
int flags, const char *name,
|
|
|
|
const struct drm_prop_enum_list *props,
|
2014-07-08 13:01:52 +08:00
|
|
|
int num_props,
|
|
|
|
uint64_t supported_bits)
|
2012-05-17 16:23:26 +08:00
|
|
|
{
|
|
|
|
struct drm_property *property;
|
2014-07-08 13:01:52 +08:00
|
|
|
int i, ret, index = 0;
|
|
|
|
int num_values = hweight64(supported_bits);
|
2012-05-17 16:23:26 +08:00
|
|
|
|
|
|
|
flags |= DRM_MODE_PROP_BITMASK;
|
|
|
|
|
|
|
|
property = drm_property_create(dev, flags, name, num_values);
|
|
|
|
if (!property)
|
|
|
|
return NULL;
|
2014-07-08 13:01:52 +08:00
|
|
|
for (i = 0; i < num_props; i++) {
|
|
|
|
if (!(supported_bits & (1ULL << props[i].type)))
|
|
|
|
continue;
|
2012-05-17 16:23:26 +08:00
|
|
|
|
2014-07-08 13:01:52 +08:00
|
|
|
if (WARN_ON(index >= num_values)) {
|
|
|
|
drm_property_destroy(dev, property);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = drm_property_add_enum(property, index++,
|
2012-05-17 16:23:26 +08:00
|
|
|
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 11:22:31 +08: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-11 04:33:02 +08:00
|
|
|
/**
|
2015-01-21 15:47:38 +08:00
|
|
|
* drm_property_create_range - create a new unsigned ranged property type
|
2014-03-11 04:33:02 +08:00
|
|
|
* @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.
|
|
|
|
*
|
2015-01-21 15:47:38 +08:00
|
|
|
* Userspace is allowed to set any unsigned integer value in the (min, max)
|
|
|
|
* range inclusive.
|
2014-03-11 04:33:02 +08:00
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* A pointer to the newly created property on success, NULL on failure.
|
|
|
|
*/
|
2012-02-06 17:58:18 +08:00
|
|
|
struct drm_property *drm_property_create_range(struct drm_device *dev, int flags,
|
|
|
|
const char *name,
|
|
|
|
uint64_t min, uint64_t max)
|
|
|
|
{
|
2012-09-13 11:22:31 +08:00
|
|
|
return property_create_range(dev, DRM_MODE_PROP_RANGE | flags,
|
|
|
|
name, min, max);
|
2012-02-06 17:58:18 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_property_create_range);
|
|
|
|
|
2015-01-21 15:47:38 +08:00
|
|
|
/**
|
|
|
|
* drm_property_create_signed_range - create a new signed 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 signed integer value in the (min, max)
|
|
|
|
* range inclusive.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* A pointer to the newly created property on success, NULL on failure.
|
|
|
|
*/
|
2012-09-13 11:22:31 +08:00
|
|
|
struct drm_property *drm_property_create_signed_range(struct drm_device *dev,
|
|
|
|
int flags, const char *name,
|
|
|
|
int64_t min, int64_t max)
|
|
|
|
{
|
|
|
|
return property_create_range(dev, DRM_MODE_PROP_SIGNED_RANGE | flags,
|
|
|
|
name, I642U64(min), I642U64(max));
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_property_create_signed_range);
|
|
|
|
|
2015-01-21 15:47:38 +08:00
|
|
|
/**
|
|
|
|
* drm_property_create_object - create a new object property type
|
|
|
|
* @dev: drm device
|
|
|
|
* @flags: flags specifying the property type
|
|
|
|
* @name: name of the property
|
|
|
|
* @type: object type from DRM_MODE_OBJECT_* defines
|
|
|
|
*
|
|
|
|
* 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 this to any property value of the given
|
|
|
|
* @type. Only useful for atomic properties, which is enforced.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* A pointer to the newly created property on success, NULL on failure.
|
|
|
|
*/
|
2014-05-30 23:37:03 +08:00
|
|
|
struct drm_property *drm_property_create_object(struct drm_device *dev,
|
|
|
|
int flags, const char *name, uint32_t type)
|
|
|
|
{
|
|
|
|
struct drm_property *property;
|
|
|
|
|
|
|
|
flags |= DRM_MODE_PROP_OBJECT;
|
|
|
|
|
2015-01-21 15:47:38 +08:00
|
|
|
if (WARN_ON(!(flags & DRM_MODE_PROP_ATOMIC)))
|
|
|
|
return NULL;
|
|
|
|
|
2014-05-30 23:37:03 +08:00
|
|
|
property = drm_property_create(dev, flags, name, 1);
|
|
|
|
if (!property)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
property->values[0] = type;
|
|
|
|
|
|
|
|
return property;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_property_create_object);
|
|
|
|
|
2015-01-21 15:47:38 +08:00
|
|
|
/**
|
|
|
|
* drm_property_create_bool - create a new boolean property type
|
|
|
|
* @dev: drm device
|
|
|
|
* @flags: flags specifying the property type
|
|
|
|
* @name: name 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.
|
|
|
|
*
|
|
|
|
* This is implemented as a ranged property with only {0, 1} as valid values.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* A pointer to the newly created property on success, NULL on failure.
|
|
|
|
*/
|
|
|
|
struct drm_property *drm_property_create_bool(struct drm_device *dev, int flags,
|
|
|
|
const char *name)
|
|
|
|
{
|
|
|
|
return drm_property_create_range(dev, flags, name, 0, 1);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_property_create_bool);
|
|
|
|
|
2014-03-11 04:33:02 +08: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-08 06:05:41 +08: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 23:34:01 +08:00
|
|
|
if (!(drm_property_type_is(property, DRM_MODE_PROP_ENUM) ||
|
|
|
|
drm_property_type_is(property, DRM_MODE_PROP_BITMASK)))
|
2012-05-17 16:23:26 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Bitmask enum properties have the additional constraint of values
|
|
|
|
* from 0 to 63
|
|
|
|
*/
|
2014-05-30 23:34:01 +08:00
|
|
|
if (drm_property_type_is(property, DRM_MODE_PROP_BITMASK) &&
|
|
|
|
(value > 63))
|
2008-11-08 06:05:41 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
2014-11-20 01:38:10 +08:00
|
|
|
if (!list_empty(&property->enum_list)) {
|
|
|
|
list_for_each_entry(prop_enum, &property->enum_list, head) {
|
2008-11-08 06:05:41 +08:00
|
|
|
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;
|
2014-11-20 01:38:10 +08:00
|
|
|
list_add_tail(&prop_enum->head, &property->enum_list);
|
2008-11-08 06:05:41 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_property_add_enum);
|
|
|
|
|
2014-03-11 04:33:02 +08: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-08 06:05:41 +08:00
|
|
|
void drm_property_destroy(struct drm_device *dev, struct drm_property *property)
|
|
|
|
{
|
|
|
|
struct drm_property_enum *prop_enum, *pt;
|
|
|
|
|
2014-11-20 01:38:10 +08:00
|
|
|
list_for_each_entry_safe(prop_enum, pt, &property->enum_list, head) {
|
2008-11-08 06:05:41 +08:00
|
|
|
list_del(&prop_enum->head);
|
|
|
|
kfree(prop_enum);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (property->num_values)
|
|
|
|
kfree(property->values);
|
2016-04-15 13:10:32 +08:00
|
|
|
drm_mode_object_unregister(dev, &property->base);
|
2008-11-08 06:05:41 +08:00
|
|
|
list_del(&property->head);
|
|
|
|
kfree(property);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_property_destroy);
|
|
|
|
|
2014-03-11 04:33:02 +08: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-16 05:09:02 +08:00
|
|
|
void drm_object_attach_property(struct drm_mode_object *obj,
|
|
|
|
struct drm_property *property,
|
|
|
|
uint64_t init_val)
|
|
|
|
{
|
2012-05-16 05:09:04 +08:00
|
|
|
int count = obj->properties->count;
|
2012-05-16 05:09:02 +08:00
|
|
|
|
2012-05-16 05:09:04 +08: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-16 05:09:02 +08:00
|
|
|
}
|
|
|
|
|
2014-12-17 07:05:30 +08:00
|
|
|
obj->properties->properties[count] = property;
|
2012-05-16 05:09:04 +08:00
|
|
|
obj->properties->values[count] = init_val;
|
|
|
|
obj->properties->count++;
|
2014-12-19 05:01:50 +08:00
|
|
|
if (property->flags & DRM_MODE_PROP_ATOMIC)
|
|
|
|
obj->properties->atomic_count++;
|
2012-05-16 05:09:02 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_object_attach_property);
|
|
|
|
|
2014-03-11 04:33:02 +08: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-16 05:09:02 +08:00
|
|
|
int drm_object_property_set_value(struct drm_mode_object *obj,
|
|
|
|
struct drm_property *property, uint64_t val)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2012-05-16 05:09:04 +08:00
|
|
|
for (i = 0; i < obj->properties->count; i++) {
|
2014-12-17 07:05:30 +08:00
|
|
|
if (obj->properties->properties[i] == property) {
|
2012-05-16 05:09:02 +08:00
|
|
|
obj->properties->values[i] = val;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_object_property_set_value);
|
|
|
|
|
2014-03-11 04:33:02 +08: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-16 05:09:02 +08:00
|
|
|
int drm_object_property_get_value(struct drm_mode_object *obj,
|
|
|
|
struct drm_property *property, uint64_t *val)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2014-12-19 05:01:50 +08:00
|
|
|
/* read-only properties bypass atomic mechanism and still store
|
|
|
|
* their value in obj->properties->values[].. mostly to avoid
|
|
|
|
* having to deal w/ EDID and similar props in atomic paths:
|
|
|
|
*/
|
|
|
|
if (drm_core_check_feature(property->dev, DRIVER_ATOMIC) &&
|
|
|
|
!(property->flags & DRM_MODE_PROP_IMMUTABLE))
|
|
|
|
return drm_atomic_get_property(obj, property, val);
|
|
|
|
|
2012-05-16 05:09:04 +08:00
|
|
|
for (i = 0; i < obj->properties->count; i++) {
|
2014-12-17 07:05:30 +08:00
|
|
|
if (obj->properties->properties[i] == property) {
|
2012-05-16 05:09:02 +08:00
|
|
|
*val = obj->properties->values[i];
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_object_property_get_value);
|
|
|
|
|
2014-03-11 04:33:02 +08:00
|
|
|
/**
|
2014-11-20 01:38:09 +08:00
|
|
|
* drm_mode_getproperty_ioctl - get the property metadata
|
2014-03-11 04:33:02 +08:00
|
|
|
* @dev: DRM device
|
|
|
|
* @data: ioctl data
|
|
|
|
* @file_priv: DRM file info
|
|
|
|
*
|
2014-11-20 01:38:09 +08:00
|
|
|
* This function retrieves the metadata for a given property, like the different
|
|
|
|
* possible values for an enum property or the limits for a range property.
|
|
|
|
*
|
|
|
|
* Blob properties are special
|
2014-03-11 04:33:02 +08:00
|
|
|
*
|
|
|
|
* Called by the user via ioctl.
|
|
|
|
*
|
|
|
|
* Returns:
|
2014-11-20 01:38:09 +08:00
|
|
|
* Zero on success, negative errno on failure.
|
2014-03-11 04:33:02 +08:00
|
|
|
*/
|
2008-11-08 06:05:41 +08: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 value_count = 0;
|
|
|
|
int ret = 0, i;
|
|
|
|
int copied;
|
|
|
|
struct drm_property_enum *prop_enum;
|
|
|
|
struct drm_mode_property_enum __user *enum_ptr;
|
|
|
|
uint64_t __user *values_ptr;
|
|
|
|
|
2011-02-08 11:55:21 +08:00
|
|
|
if (!drm_core_check_feature(dev, DRIVER_MODESET))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2012-12-02 07:28:11 +08:00
|
|
|
drm_modeset_lock_all(dev);
|
2013-10-06 04:36:52 +08:00
|
|
|
property = drm_property_find(dev, out_resp->prop_id);
|
|
|
|
if (!property) {
|
2013-10-17 18:35:00 +08:00
|
|
|
ret = -ENOENT;
|
2008-11-08 06:05:41 +08:00
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
2014-05-30 23:34:01 +08:00
|
|
|
if (drm_property_type_is(property, DRM_MODE_PROP_ENUM) ||
|
|
|
|
drm_property_type_is(property, DRM_MODE_PROP_BITMASK)) {
|
2014-11-20 01:38:10 +08:00
|
|
|
list_for_each_entry(prop_enum, &property->enum_list, head)
|
2008-11-08 06:05:41 +08:00
|
|
|
enum_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-20 06:06:42 +08:00
|
|
|
values_ptr = (uint64_t __user *)(unsigned long)out_resp->values_ptr;
|
2008-11-08 06:05:41 +08: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 23:34:01 +08:00
|
|
|
if (drm_property_type_is(property, DRM_MODE_PROP_ENUM) ||
|
|
|
|
drm_property_type_is(property, DRM_MODE_PROP_BITMASK)) {
|
2008-11-08 06:05:41 +08:00
|
|
|
if ((out_resp->count_enum_blobs >= enum_count) && enum_count) {
|
|
|
|
copied = 0;
|
2011-12-20 06:06:42 +08:00
|
|
|
enum_ptr = (struct drm_mode_property_enum __user *)(unsigned long)out_resp->enum_blob_ptr;
|
2014-11-20 01:38:10 +08:00
|
|
|
list_for_each_entry(prop_enum, &property->enum_list, head) {
|
2008-11-08 06:05:41 +08:00
|
|
|
|
|
|
|
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-11-20 01:38:10 +08:00
|
|
|
/*
|
|
|
|
* NOTE: The idea seems to have been to use this to read all the blob
|
|
|
|
* property values. But nothing ever added them to the corresponding
|
|
|
|
* list, userspace always used the special-purpose get_blob ioctl to
|
|
|
|
* read the value for a blob property. It also doesn't make a lot of
|
|
|
|
* sense to return values here when everything else is just metadata for
|
|
|
|
* the property itself.
|
|
|
|
*/
|
|
|
|
if (drm_property_type_is(property, DRM_MODE_PROP_BLOB))
|
|
|
|
out_resp->count_enum_blobs = 0;
|
2008-11-08 06:05:41 +08:00
|
|
|
done:
|
2012-12-02 07:28:11 +08:00
|
|
|
drm_modeset_unlock_all(dev);
|
2008-11-08 06:05:41 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-04-23 04:10:30 +08:00
|
|
|
static void drm_property_free_blob(struct kref *kref)
|
|
|
|
{
|
|
|
|
struct drm_property_blob *blob =
|
|
|
|
container_of(kref, struct drm_property_blob, base.refcount);
|
|
|
|
|
|
|
|
mutex_lock(&blob->dev->mode_config.blob_lock);
|
|
|
|
list_del(&blob->head_global);
|
|
|
|
mutex_unlock(&blob->dev->mode_config.blob_lock);
|
|
|
|
|
|
|
|
drm_mode_object_unregister(blob->dev, &blob->base);
|
|
|
|
|
|
|
|
kfree(blob);
|
|
|
|
}
|
|
|
|
|
2015-05-22 20:34:49 +08:00
|
|
|
/**
|
|
|
|
* drm_property_create_blob - Create new blob property
|
|
|
|
*
|
|
|
|
* Creates a new blob property for a specified DRM device, optionally
|
|
|
|
* copying data.
|
|
|
|
*
|
|
|
|
* @dev: DRM device to create property for
|
|
|
|
* @length: Length to allocate for blob data
|
|
|
|
* @data: If specified, copies data into blob
|
2015-05-22 20:34:50 +08:00
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* New blob property with a single reference on success, or an ERR_PTR
|
|
|
|
* value on failure.
|
2015-05-22 20:34:49 +08:00
|
|
|
*/
|
2015-04-21 02:22:55 +08:00
|
|
|
struct drm_property_blob *
|
2014-05-13 17:36:13 +08:00
|
|
|
drm_property_create_blob(struct drm_device *dev, size_t length,
|
2014-05-13 17:38:36 +08:00
|
|
|
const void *data)
|
2008-11-08 06:05:41 +08:00
|
|
|
{
|
|
|
|
struct drm_property_blob *blob;
|
2012-03-13 18:35:48 +08:00
|
|
|
int ret;
|
2008-11-08 06:05:41 +08:00
|
|
|
|
2015-10-29 21:37:54 +08:00
|
|
|
if (!length || length > ULONG_MAX - sizeof(struct drm_property_blob))
|
2015-05-22 20:34:50 +08:00
|
|
|
return ERR_PTR(-EINVAL);
|
2008-11-08 06:05:41 +08:00
|
|
|
|
|
|
|
blob = kzalloc(sizeof(struct drm_property_blob)+length, GFP_KERNEL);
|
|
|
|
if (!blob)
|
2015-05-22 20:34:50 +08:00
|
|
|
return ERR_PTR(-ENOMEM);
|
2008-11-08 06:05:41 +08:00
|
|
|
|
2015-05-22 20:34:51 +08:00
|
|
|
/* This must be explicitly initialised, so we can safely call list_del
|
|
|
|
* on it in the removal handler, even if it isn't in a file list. */
|
|
|
|
INIT_LIST_HEAD(&blob->head_file);
|
2015-04-21 02:22:54 +08:00
|
|
|
blob->length = length;
|
2015-04-21 02:22:55 +08:00
|
|
|
blob->dev = dev;
|
2015-04-21 02:22:54 +08:00
|
|
|
|
2015-05-22 20:34:49 +08:00
|
|
|
if (data)
|
|
|
|
memcpy(blob->data, data, length);
|
2015-04-21 02:22:54 +08:00
|
|
|
|
2016-04-23 04:10:30 +08:00
|
|
|
ret = drm_mode_object_get_reg(dev, &blob->base, DRM_MODE_OBJECT_BLOB,
|
|
|
|
true, drm_property_free_blob);
|
2012-03-13 18:35:48 +08:00
|
|
|
if (ret) {
|
|
|
|
kfree(blob);
|
2015-05-22 20:34:50 +08:00
|
|
|
return ERR_PTR(-EINVAL);
|
2012-03-13 18:35:48 +08:00
|
|
|
}
|
|
|
|
|
2016-04-23 04:10:30 +08:00
|
|
|
mutex_lock(&dev->mode_config.blob_lock);
|
2015-05-22 20:34:51 +08:00
|
|
|
list_add_tail(&blob->head_global,
|
|
|
|
&dev->mode_config.property_blob_list);
|
2015-04-21 02:22:54 +08:00
|
|
|
mutex_unlock(&dev->mode_config.blob_lock);
|
2008-11-08 06:05:41 +08:00
|
|
|
|
|
|
|
return blob;
|
|
|
|
}
|
2015-04-21 02:22:55 +08:00
|
|
|
EXPORT_SYMBOL(drm_property_create_blob);
|
2008-11-08 06:05:41 +08:00
|
|
|
|
2015-04-21 02:22:55 +08:00
|
|
|
/**
|
|
|
|
* drm_property_unreference_blob - Unreference a blob property
|
|
|
|
*
|
|
|
|
* Drop a reference on a blob property. May free the object.
|
|
|
|
*
|
2015-05-22 20:34:44 +08:00
|
|
|
* @blob: Pointer to blob property
|
2015-04-21 02:22:55 +08:00
|
|
|
*/
|
|
|
|
void drm_property_unreference_blob(struct drm_property_blob *blob)
|
|
|
|
{
|
|
|
|
if (!blob)
|
|
|
|
return;
|
|
|
|
|
2016-04-23 04:10:30 +08:00
|
|
|
drm_mode_object_unreference(&blob->base);
|
2015-04-21 02:22:55 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_property_unreference_blob);
|
|
|
|
|
2015-05-22 20:34:51 +08:00
|
|
|
/**
|
|
|
|
* drm_property_destroy_user_blobs - destroy all blobs created by this client
|
|
|
|
* @dev: DRM device
|
|
|
|
* @file_priv: destroy all blobs owned by this file handle
|
|
|
|
*/
|
|
|
|
void drm_property_destroy_user_blobs(struct drm_device *dev,
|
|
|
|
struct drm_file *file_priv)
|
|
|
|
{
|
|
|
|
struct drm_property_blob *blob, *bt;
|
|
|
|
|
2016-04-23 04:10:30 +08:00
|
|
|
/*
|
|
|
|
* When the file gets released that means no one else can access the
|
|
|
|
* blob list any more, so no need to grab dev->blob_lock.
|
|
|
|
*/
|
2015-05-22 20:34:51 +08:00
|
|
|
list_for_each_entry_safe(blob, bt, &file_priv->blobs, head_file) {
|
|
|
|
list_del_init(&blob->head_file);
|
2016-04-23 04:10:30 +08:00
|
|
|
drm_property_unreference_blob(blob);
|
2015-05-22 20:34:51 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-04-21 02:22:55 +08:00
|
|
|
/**
|
|
|
|
* drm_property_reference_blob - Take a reference on an existing property
|
|
|
|
*
|
|
|
|
* Take a new reference on an existing blob property.
|
|
|
|
*
|
2015-05-22 20:34:44 +08:00
|
|
|
* @blob: Pointer to blob property
|
2015-04-21 02:22:55 +08:00
|
|
|
*/
|
|
|
|
struct drm_property_blob *drm_property_reference_blob(struct drm_property_blob *blob)
|
|
|
|
{
|
2016-04-23 04:10:30 +08:00
|
|
|
drm_mode_object_reference(&blob->base);
|
2015-04-21 02:22:55 +08:00
|
|
|
return blob;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_property_reference_blob);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_property_lookup_blob - look up a blob property and take a reference
|
|
|
|
* @dev: drm device
|
|
|
|
* @id: id of the blob property
|
|
|
|
*
|
|
|
|
* If successful, this takes an additional reference to the blob property.
|
|
|
|
* callers need to make sure to eventually unreference the returned property
|
|
|
|
* again, using @drm_property_unreference_blob.
|
|
|
|
*/
|
|
|
|
struct drm_property_blob *drm_property_lookup_blob(struct drm_device *dev,
|
|
|
|
uint32_t id)
|
|
|
|
{
|
2016-04-23 04:10:30 +08:00
|
|
|
struct drm_mode_object *obj;
|
|
|
|
struct drm_property_blob *blob = NULL;
|
2015-04-21 02:22:55 +08:00
|
|
|
|
2016-08-15 22:07:02 +08:00
|
|
|
obj = __drm_mode_object_find(dev, id, DRM_MODE_OBJECT_BLOB);
|
2016-04-23 04:10:30 +08:00
|
|
|
if (obj)
|
|
|
|
blob = obj_to_blob(obj);
|
2015-04-21 02:22:55 +08:00
|
|
|
return blob;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_property_lookup_blob);
|
|
|
|
|
2015-04-21 02:22:53 +08:00
|
|
|
/**
|
|
|
|
* drm_property_replace_global_blob - atomically replace existing blob property
|
|
|
|
* @dev: drm device
|
|
|
|
* @replace: location of blob property pointer to be replaced
|
|
|
|
* @length: length of data for new blob, or 0 for no data
|
|
|
|
* @data: content for new blob, or NULL for no data
|
|
|
|
* @obj_holds_id: optional object for property holding blob ID
|
|
|
|
* @prop_holds_id: optional property holding blob ID
|
|
|
|
* @return 0 on success or error on failure
|
|
|
|
*
|
|
|
|
* This function will atomically replace a global property in the blob list,
|
|
|
|
* optionally updating a property which holds the ID of that property. It is
|
|
|
|
* guaranteed to be atomic: no caller will be allowed to see intermediate
|
|
|
|
* results, and either the entire operation will succeed and clean up the
|
|
|
|
* previous property, or it will fail and the state will be unchanged.
|
|
|
|
*
|
|
|
|
* If length is 0 or data is NULL, no new blob will be created, and the holding
|
|
|
|
* property, if specified, will be set to 0.
|
|
|
|
*
|
|
|
|
* Access to the replace pointer is assumed to be protected by the caller, e.g.
|
|
|
|
* by holding the relevant modesetting object lock for its parent.
|
|
|
|
*
|
|
|
|
* For example, a drm_connector has a 'PATH' property, which contains the ID
|
|
|
|
* of a blob property with the value of the MST path information. Calling this
|
|
|
|
* function with replace pointing to the connector's path_blob_ptr, length and
|
|
|
|
* data set for the new path information, obj_holds_id set to the connector's
|
|
|
|
* base object, and prop_holds_id set to the path property name, will perform
|
|
|
|
* a completely atomic update. The access to path_blob_ptr is protected by the
|
|
|
|
* caller holding a lock on the connector.
|
|
|
|
*/
|
2016-08-13 04:48:49 +08:00
|
|
|
int drm_property_replace_global_blob(struct drm_device *dev,
|
|
|
|
struct drm_property_blob **replace,
|
|
|
|
size_t length,
|
|
|
|
const void *data,
|
|
|
|
struct drm_mode_object *obj_holds_id,
|
|
|
|
struct drm_property *prop_holds_id)
|
2015-04-21 02:22:53 +08:00
|
|
|
{
|
|
|
|
struct drm_property_blob *new_blob = NULL;
|
|
|
|
struct drm_property_blob *old_blob = NULL;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
WARN_ON(replace == NULL);
|
|
|
|
|
|
|
|
old_blob = *replace;
|
|
|
|
|
|
|
|
if (length && data) {
|
|
|
|
new_blob = drm_property_create_blob(dev, length, data);
|
2015-05-22 20:34:50 +08:00
|
|
|
if (IS_ERR(new_blob))
|
|
|
|
return PTR_ERR(new_blob);
|
2015-04-21 02:22:53 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* This does not need to be synchronised with blob_lock, as the
|
|
|
|
* get_properties ioctl locks all modesetting objects, and
|
|
|
|
* obj_holds_id must be locked before calling here, so we cannot
|
|
|
|
* have its value out of sync with the list membership modified
|
|
|
|
* below under blob_lock. */
|
|
|
|
if (obj_holds_id) {
|
|
|
|
ret = drm_object_property_set_value(obj_holds_id,
|
|
|
|
prop_holds_id,
|
|
|
|
new_blob ?
|
|
|
|
new_blob->base.id : 0);
|
|
|
|
if (ret != 0)
|
|
|
|
goto err_created;
|
|
|
|
}
|
|
|
|
|
2015-07-06 03:55:10 +08:00
|
|
|
drm_property_unreference_blob(old_blob);
|
2015-04-21 02:22:53 +08:00
|
|
|
*replace = new_blob;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err_created:
|
2015-04-21 02:22:55 +08:00
|
|
|
drm_property_unreference_blob(new_blob);
|
2015-04-21 02:22:53 +08:00
|
|
|
return ret;
|
|
|
|
}
|
2016-08-13 04:48:49 +08:00
|
|
|
EXPORT_SYMBOL(drm_property_replace_global_blob);
|
2015-04-21 02:22:53 +08:00
|
|
|
|
2014-03-11 04:33:02 +08: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:
|
2014-11-20 01:38:09 +08:00
|
|
|
* Zero on success, negative errno on failure.
|
2014-03-11 04:33:02 +08:00
|
|
|
*/
|
2008-11-08 06:05:41 +08: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-20 06:06:42 +08:00
|
|
|
void __user *blob_ptr;
|
2008-11-08 06:05:41 +08:00
|
|
|
|
2011-02-08 11:55:21 +08:00
|
|
|
if (!drm_core_check_feature(dev, DRIVER_MODESET))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2016-04-23 04:10:30 +08:00
|
|
|
blob = drm_property_lookup_blob(dev, out_resp->blob_id);
|
|
|
|
if (!blob)
|
|
|
|
return -ENOENT;
|
2008-11-08 06:05:41 +08:00
|
|
|
|
|
|
|
if (out_resp->length == blob->length) {
|
2011-12-20 06:06:42 +08:00
|
|
|
blob_ptr = (void __user *)(unsigned long)out_resp->data;
|
2014-12-10 20:03:34 +08:00
|
|
|
if (copy_to_user(blob_ptr, blob->data, blob->length)) {
|
2008-11-08 06:05:41 +08:00
|
|
|
ret = -EFAULT;
|
2016-04-23 04:10:30 +08:00
|
|
|
goto unref;
|
2008-11-08 06:05:41 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
out_resp->length = blob->length;
|
2016-04-23 04:10:30 +08:00
|
|
|
unref:
|
|
|
|
drm_property_unreference_blob(blob);
|
2008-11-08 06:05:41 +08:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-05-22 20:34:51 +08:00
|
|
|
/**
|
|
|
|
* drm_mode_createblob_ioctl - create a new blob property
|
|
|
|
* @dev: DRM device
|
|
|
|
* @data: ioctl data
|
|
|
|
* @file_priv: DRM file info
|
|
|
|
*
|
|
|
|
* This function creates a new blob property with user-defined values. In order
|
|
|
|
* to give us sensible validation and checking when creating, rather than at
|
|
|
|
* every potential use, we also require a type to be provided upfront.
|
|
|
|
*
|
|
|
|
* Called by the user via ioctl.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* Zero on success, negative errno on failure.
|
|
|
|
*/
|
|
|
|
int drm_mode_createblob_ioctl(struct drm_device *dev,
|
|
|
|
void *data, struct drm_file *file_priv)
|
|
|
|
{
|
|
|
|
struct drm_mode_create_blob *out_resp = data;
|
|
|
|
struct drm_property_blob *blob;
|
|
|
|
void __user *blob_ptr;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (!drm_core_check_feature(dev, DRIVER_MODESET))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
blob = drm_property_create_blob(dev, out_resp->length, NULL);
|
|
|
|
if (IS_ERR(blob))
|
|
|
|
return PTR_ERR(blob);
|
|
|
|
|
|
|
|
blob_ptr = (void __user *)(unsigned long)out_resp->data;
|
|
|
|
if (copy_from_user(blob->data, blob_ptr, out_resp->length)) {
|
|
|
|
ret = -EFAULT;
|
|
|
|
goto out_blob;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Dropping the lock between create_blob and our access here is safe
|
|
|
|
* as only the same file_priv can remove the blob; at this point, it is
|
|
|
|
* not associated with any file_priv. */
|
|
|
|
mutex_lock(&dev->mode_config.blob_lock);
|
|
|
|
out_resp->blob_id = blob->base.id;
|
2015-10-08 22:10:24 +08:00
|
|
|
list_add_tail(&blob->head_file, &file_priv->blobs);
|
2015-05-22 20:34:51 +08:00
|
|
|
mutex_unlock(&dev->mode_config.blob_lock);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
out_blob:
|
|
|
|
drm_property_unreference_blob(blob);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_mode_destroyblob_ioctl - destroy a user blob property
|
|
|
|
* @dev: DRM device
|
|
|
|
* @data: ioctl data
|
|
|
|
* @file_priv: DRM file info
|
|
|
|
*
|
|
|
|
* Destroy an existing user-defined blob property.
|
|
|
|
*
|
|
|
|
* Called by the user via ioctl.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* Zero on success, negative errno on failure.
|
|
|
|
*/
|
|
|
|
int drm_mode_destroyblob_ioctl(struct drm_device *dev,
|
|
|
|
void *data, struct drm_file *file_priv)
|
|
|
|
{
|
|
|
|
struct drm_mode_destroy_blob *out_resp = data;
|
|
|
|
struct drm_property_blob *blob = NULL, *bt;
|
|
|
|
bool found = false;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (!drm_core_check_feature(dev, DRIVER_MODESET))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2016-04-23 04:10:30 +08:00
|
|
|
blob = drm_property_lookup_blob(dev, out_resp->blob_id);
|
|
|
|
if (!blob)
|
|
|
|
return -ENOENT;
|
2015-05-22 20:34:51 +08:00
|
|
|
|
2016-04-23 04:10:30 +08:00
|
|
|
mutex_lock(&dev->mode_config.blob_lock);
|
2015-05-22 20:34:51 +08:00
|
|
|
/* Ensure the property was actually created by this user. */
|
|
|
|
list_for_each_entry(bt, &file_priv->blobs, head_file) {
|
|
|
|
if (bt == blob) {
|
|
|
|
found = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!found) {
|
|
|
|
ret = -EPERM;
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* We must drop head_file here, because we may not be the last
|
|
|
|
* reference on the blob. */
|
|
|
|
list_del_init(&blob->head_file);
|
|
|
|
mutex_unlock(&dev->mode_config.blob_lock);
|
|
|
|
|
2016-04-23 04:10:30 +08:00
|
|
|
/* One reference from lookup, and one from the filp. */
|
|
|
|
drm_property_unreference_blob(blob);
|
|
|
|
drm_property_unreference_blob(blob);
|
|
|
|
|
2015-05-22 20:34:51 +08:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
err:
|
|
|
|
mutex_unlock(&dev->mode_config.blob_lock);
|
2016-04-23 04:10:30 +08:00
|
|
|
drm_property_unreference_blob(blob);
|
|
|
|
|
2015-05-22 20:34:51 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-10-22 10:03:04 +08:00
|
|
|
/**
|
|
|
|
* drm_mode_connector_set_path_property - set tile property on connector
|
|
|
|
* @connector: connector to set property on.
|
2015-04-21 02:22:53 +08:00
|
|
|
* @path: path to use for property; must not be NULL.
|
2014-10-22 10:03:04 +08:00
|
|
|
*
|
|
|
|
* This creates a property to expose to userspace to specify a
|
|
|
|
* connector path. This is mainly used for DisplayPort MST where
|
|
|
|
* connectors have a topology and we want to allow userspace to give
|
|
|
|
* them more meaningful names.
|
|
|
|
*
|
|
|
|
* Returns:
|
2014-11-20 01:38:09 +08:00
|
|
|
* Zero on success, negative errno on failure.
|
2014-10-22 10:03:04 +08:00
|
|
|
*/
|
2014-06-05 12:01:31 +08:00
|
|
|
int drm_mode_connector_set_path_property(struct drm_connector *connector,
|
2014-05-13 17:38:36 +08:00
|
|
|
const char *path)
|
2014-06-05 12:01:31 +08:00
|
|
|
{
|
|
|
|
struct drm_device *dev = connector->dev;
|
2014-05-13 17:36:13 +08:00
|
|
|
int ret;
|
2014-06-05 12:01:31 +08:00
|
|
|
|
2015-04-21 02:22:53 +08:00
|
|
|
ret = drm_property_replace_global_blob(dev,
|
|
|
|
&connector->path_blob_ptr,
|
|
|
|
strlen(path) + 1,
|
|
|
|
path,
|
|
|
|
&connector->base,
|
|
|
|
dev->mode_config.path_property);
|
2014-06-05 12:01:31 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_mode_connector_set_path_property);
|
|
|
|
|
2014-10-20 14:30:50 +08:00
|
|
|
/**
|
|
|
|
* drm_mode_connector_set_tile_property - set tile property on connector
|
|
|
|
* @connector: connector to set property on.
|
|
|
|
*
|
|
|
|
* This looks up the tile information for a connector, and creates a
|
|
|
|
* property for userspace to parse if it exists. The property is of
|
|
|
|
* the form of 8 integers using ':' as a separator.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* Zero on success, errno on failure.
|
|
|
|
*/
|
|
|
|
int drm_mode_connector_set_tile_property(struct drm_connector *connector)
|
|
|
|
{
|
|
|
|
struct drm_device *dev = connector->dev;
|
|
|
|
char tile[256];
|
2015-04-21 02:22:53 +08:00
|
|
|
int ret;
|
2014-10-20 14:30:50 +08:00
|
|
|
|
|
|
|
if (!connector->has_tile) {
|
2015-04-21 02:22:53 +08:00
|
|
|
ret = drm_property_replace_global_blob(dev,
|
|
|
|
&connector->tile_blob_ptr,
|
|
|
|
0,
|
|
|
|
NULL,
|
|
|
|
&connector->base,
|
|
|
|
dev->mode_config.tile_property);
|
2014-10-20 14:30:50 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
snprintf(tile, 256, "%d:%d:%d:%d:%d:%d:%d:%d",
|
|
|
|
connector->tile_group->id, connector->tile_is_single_monitor,
|
|
|
|
connector->num_h_tile, connector->num_v_tile,
|
|
|
|
connector->tile_h_loc, connector->tile_v_loc,
|
|
|
|
connector->tile_h_size, connector->tile_v_size);
|
|
|
|
|
2015-04-21 02:22:53 +08:00
|
|
|
ret = drm_property_replace_global_blob(dev,
|
|
|
|
&connector->tile_blob_ptr,
|
|
|
|
strlen(tile) + 1,
|
|
|
|
tile,
|
|
|
|
&connector->base,
|
|
|
|
dev->mode_config.tile_property);
|
2014-10-20 14:30:50 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_mode_connector_set_tile_property);
|
|
|
|
|
2014-03-11 04:33:02 +08: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:
|
2014-11-20 01:38:09 +08:00
|
|
|
* Zero on success, negative errno on failure.
|
2014-03-11 04:33:02 +08:00
|
|
|
*/
|
2008-11-08 06:05:41 +08:00
|
|
|
int drm_mode_connector_update_edid_property(struct drm_connector *connector,
|
2014-05-13 17:38:36 +08:00
|
|
|
const struct edid *edid)
|
2008-11-08 06:05:41 +08:00
|
|
|
{
|
|
|
|
struct drm_device *dev = connector->dev;
|
2015-04-21 02:22:53 +08:00
|
|
|
size_t size = 0;
|
2014-05-13 17:36:13 +08:00
|
|
|
int ret;
|
2008-11-08 06:05:41 +08:00
|
|
|
|
2014-06-19 00:52:33 +08:00
|
|
|
/* ignore requests to set edid when overridden */
|
|
|
|
if (connector->override_edid)
|
|
|
|
return 0;
|
|
|
|
|
2015-04-21 02:22:53 +08:00
|
|
|
if (edid)
|
2015-07-03 14:46:50 +08:00
|
|
|
size = EDID_LENGTH * (1 + edid->extensions);
|
2008-11-08 06:05:41 +08:00
|
|
|
|
2015-04-21 02:22:53 +08:00
|
|
|
ret = drm_property_replace_global_blob(dev,
|
|
|
|
&connector->edid_blob_ptr,
|
|
|
|
size,
|
|
|
|
edid,
|
|
|
|
&connector->base,
|
|
|
|
dev->mode_config.edid_property);
|
2008-11-08 06:05:41 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_mode_connector_update_edid_property);
|
|
|
|
|
2014-12-17 07:05:29 +08:00
|
|
|
/* Some properties could refer to dynamic refcnt'd objects, or things that
|
|
|
|
* need special locking to handle lifetime issues (ie. to ensure the prop
|
|
|
|
* value doesn't become invalid part way through the property update due to
|
|
|
|
* race). The value returned by reference via 'obj' should be passed back
|
|
|
|
* to drm_property_change_valid_put() after the property is set (and the
|
|
|
|
* object to which the property is attached has a chance to take it's own
|
|
|
|
* reference).
|
|
|
|
*/
|
2014-12-19 05:01:56 +08:00
|
|
|
bool drm_property_change_valid_get(struct drm_property *property,
|
2014-12-17 07:05:29 +08:00
|
|
|
uint64_t value, struct drm_mode_object **ref)
|
2012-05-16 05:08:59 +08:00
|
|
|
{
|
2014-12-10 20:03:39 +08:00
|
|
|
int i;
|
|
|
|
|
2012-05-16 05:08:59 +08:00
|
|
|
if (property->flags & DRM_MODE_PROP_IMMUTABLE)
|
|
|
|
return false;
|
2014-05-30 23:34:01 +08:00
|
|
|
|
2014-12-17 07:05:29 +08:00
|
|
|
*ref = NULL;
|
|
|
|
|
2014-05-30 23:34:01 +08:00
|
|
|
if (drm_property_type_is(property, DRM_MODE_PROP_RANGE)) {
|
2012-05-16 05:08:59 +08:00
|
|
|
if (value < property->values[0] || value > property->values[1])
|
|
|
|
return false;
|
|
|
|
return true;
|
2012-09-13 11:22:31 +08:00
|
|
|
} else if (drm_property_type_is(property, DRM_MODE_PROP_SIGNED_RANGE)) {
|
|
|
|
int64_t svalue = U642I64(value);
|
2014-12-10 20:03:34 +08:00
|
|
|
|
2012-09-13 11:22:31 +08:00
|
|
|
if (svalue < U642I64(property->values[0]) ||
|
|
|
|
svalue > U642I64(property->values[1]))
|
|
|
|
return false;
|
|
|
|
return true;
|
2014-05-30 23:34:01 +08:00
|
|
|
} else if (drm_property_type_is(property, DRM_MODE_PROP_BITMASK)) {
|
2012-05-25 01:53:58 +08:00
|
|
|
uint64_t valid_mask = 0;
|
2014-12-10 20:03:34 +08:00
|
|
|
|
2012-05-17 16:23:26 +08:00
|
|
|
for (i = 0; i < property->num_values; i++)
|
|
|
|
valid_mask |= (1ULL << property->values[i]);
|
|
|
|
return !(value & ~valid_mask);
|
2014-05-30 23:34:01 +08:00
|
|
|
} else if (drm_property_type_is(property, DRM_MODE_PROP_BLOB)) {
|
2015-04-21 02:22:55 +08:00
|
|
|
struct drm_property_blob *blob;
|
|
|
|
|
|
|
|
if (value == 0)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
blob = drm_property_lookup_blob(property->dev, value);
|
|
|
|
if (blob) {
|
|
|
|
*ref = &blob->base;
|
|
|
|
return true;
|
|
|
|
} else {
|
|
|
|
return false;
|
|
|
|
}
|
2014-05-30 23:37:03 +08:00
|
|
|
} else if (drm_property_type_is(property, DRM_MODE_PROP_OBJECT)) {
|
|
|
|
/* a zero value for an object property translates to null: */
|
|
|
|
if (value == 0)
|
|
|
|
return true;
|
2014-12-17 07:05:29 +08:00
|
|
|
|
2016-08-15 22:07:02 +08:00
|
|
|
*ref = __drm_mode_object_find(property->dev, value,
|
|
|
|
property->values[0]);
|
2016-05-31 20:03:18 +08:00
|
|
|
return *ref != NULL;
|
2012-05-16 05:08:59 +08:00
|
|
|
}
|
2014-12-10 20:03:39 +08:00
|
|
|
|
|
|
|
for (i = 0; i < property->num_values; i++)
|
|
|
|
if (property->values[i] == value)
|
|
|
|
return true;
|
|
|
|
return false;
|
2012-05-16 05:08:59 +08:00
|
|
|
}
|
|
|
|
|
2014-12-19 05:01:56 +08:00
|
|
|
void drm_property_change_valid_put(struct drm_property *property,
|
2014-12-17 07:05:29 +08:00
|
|
|
struct drm_mode_object *ref)
|
|
|
|
{
|
|
|
|
if (!ref)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (drm_property_type_is(property, DRM_MODE_PROP_OBJECT)) {
|
2016-04-15 13:10:42 +08:00
|
|
|
drm_mode_object_unreference(ref);
|
2015-05-26 02:11:49 +08:00
|
|
|
} else if (drm_property_type_is(property, DRM_MODE_PROP_BLOB))
|
|
|
|
drm_property_unreference_blob(obj_to_blob(ref));
|
2014-12-17 07:05:29 +08:00
|
|
|
}
|
|
|
|
|
2014-03-11 04:33:02 +08: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:
|
2014-11-20 01:38:09 +08:00
|
|
|
* Zero on success, negative errno on failure.
|
2014-03-11 04:33:02 +08:00
|
|
|
*/
|
2008-11-08 06:05:41 +08:00
|
|
|
int drm_mode_connector_property_set_ioctl(struct drm_device *dev,
|
|
|
|
void *data, struct drm_file *file_priv)
|
|
|
|
{
|
2012-05-16 05:09:03 +08: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 11:55:21 +08:00
|
|
|
|
2012-05-16 05:09:03 +08: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-08 06:05:41 +08:00
|
|
|
}
|
|
|
|
|
2012-05-16 05:09:02 +08: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) {
|
2015-12-04 16:45:59 +08:00
|
|
|
ret = (*connector->funcs->dpms)(connector, (int)value);
|
2012-05-16 05:09:02 +08:00
|
|
|
} 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 09:50:56 +08:00
|
|
|
drm_object_property_set_value(&connector->base, property, value);
|
2012-05-16 05:09:02 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-05-16 05:09:05 +08: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;
|
|
|
|
}
|
|
|
|
|
2014-08-20 21:45:00 +08:00
|
|
|
/**
|
|
|
|
* drm_mode_plane_set_obj_prop - set the value of a property
|
|
|
|
* @plane: drm plane object to set property value for
|
|
|
|
* @property: property to set
|
|
|
|
* @value: value the property should be set to
|
|
|
|
*
|
|
|
|
* This functions sets a given property on a given plane object. This function
|
|
|
|
* calls the driver's ->set_property callback and changes the software state of
|
|
|
|
* the property if the callback succeeds.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* Zero on success, error code on failure.
|
|
|
|
*/
|
|
|
|
int drm_mode_plane_set_obj_prop(struct drm_plane *plane,
|
|
|
|
struct drm_property *property,
|
|
|
|
uint64_t value)
|
2012-05-17 16:23:27 +08:00
|
|
|
{
|
|
|
|
int ret = -EINVAL;
|
2014-08-20 21:45:00 +08:00
|
|
|
struct drm_mode_object *obj = &plane->base;
|
2012-05-17 16:23:27 +08:00
|
|
|
|
|
|
|
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-08-20 21:45:00 +08:00
|
|
|
EXPORT_SYMBOL(drm_mode_plane_set_obj_prop);
|
2012-05-17 16:23:27 +08:00
|
|
|
|
2014-03-11 04:33:02 +08:00
|
|
|
/**
|
2014-11-20 01:38:09 +08:00
|
|
|
* drm_mode_obj_get_properties_ioctl - get the current value of a object's property
|
2014-03-11 04:33:02 +08:00
|
|
|
* @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:
|
2014-11-20 01:38:09 +08:00
|
|
|
* Zero on success, negative errno on failure.
|
2014-03-11 04:33:02 +08:00
|
|
|
*/
|
2012-05-16 05:09:02 +08: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;
|
|
|
|
|
|
|
|
if (!drm_core_check_feature(dev, DRIVER_MODESET))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2012-12-02 07:28:11 +08:00
|
|
|
drm_modeset_lock_all(dev);
|
2012-05-16 05:09:02 +08:00
|
|
|
|
|
|
|
obj = drm_mode_object_find(dev, arg->obj_id, arg->obj_type);
|
|
|
|
if (!obj) {
|
2013-10-17 18:35:00 +08:00
|
|
|
ret = -ENOENT;
|
2012-05-16 05:09:02 +08:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
if (!obj->properties) {
|
|
|
|
ret = -EINVAL;
|
2016-04-23 04:10:28 +08:00
|
|
|
goto out_unref;
|
2012-05-16 05:09:02 +08:00
|
|
|
}
|
|
|
|
|
2014-12-19 05:01:50 +08:00
|
|
|
ret = get_properties(obj, file_priv->atomic,
|
2014-12-19 05:01:49 +08:00
|
|
|
(uint32_t __user *)(unsigned long)(arg->props_ptr),
|
|
|
|
(uint64_t __user *)(unsigned long)(arg->prop_values_ptr),
|
|
|
|
&arg->count_props);
|
2012-05-16 05:09:02 +08:00
|
|
|
|
2016-04-23 04:10:28 +08:00
|
|
|
out_unref:
|
|
|
|
drm_mode_object_unreference(obj);
|
2012-05-16 05:09:02 +08:00
|
|
|
out:
|
2012-12-02 07:28:11 +08:00
|
|
|
drm_modeset_unlock_all(dev);
|
2012-05-16 05:09:02 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-03-11 04:33:02 +08: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:
|
2014-11-20 01:38:09 +08:00
|
|
|
* Zero on success, negative errno on failure.
|
2014-03-11 04:33:02 +08:00
|
|
|
*/
|
2012-05-16 05:09:02 +08: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;
|
2014-12-17 07:05:29 +08:00
|
|
|
int i, ret = -EINVAL;
|
|
|
|
struct drm_mode_object *ref;
|
2012-05-16 05:09:02 +08:00
|
|
|
|
|
|
|
if (!drm_core_check_feature(dev, DRIVER_MODESET))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2012-12-02 07:28:11 +08:00
|
|
|
drm_modeset_lock_all(dev);
|
2012-05-16 05:09:02 +08:00
|
|
|
|
|
|
|
arg_obj = drm_mode_object_find(dev, arg->obj_id, arg->obj_type);
|
2013-10-17 18:35:00 +08:00
|
|
|
if (!arg_obj) {
|
|
|
|
ret = -ENOENT;
|
2012-05-16 05:09:02 +08:00
|
|
|
goto out;
|
2013-10-17 18:35:00 +08:00
|
|
|
}
|
2012-05-16 05:09:02 +08:00
|
|
|
if (!arg_obj->properties)
|
2016-04-23 04:10:28 +08:00
|
|
|
goto out_unref;
|
2012-05-16 05:09:02 +08:00
|
|
|
|
2012-05-16 05:09:04 +08:00
|
|
|
for (i = 0; i < arg_obj->properties->count; i++)
|
2014-12-17 07:05:30 +08:00
|
|
|
if (arg_obj->properties->properties[i]->base.id == arg->prop_id)
|
2012-05-16 05:09:02 +08:00
|
|
|
break;
|
|
|
|
|
2012-05-16 05:09:04 +08:00
|
|
|
if (i == arg_obj->properties->count)
|
2016-04-23 04:10:28 +08:00
|
|
|
goto out_unref;
|
2012-05-16 05:09:02 +08:00
|
|
|
|
|
|
|
prop_obj = drm_mode_object_find(dev, arg->prop_id,
|
|
|
|
DRM_MODE_OBJECT_PROPERTY);
|
2013-10-17 18:35:00 +08:00
|
|
|
if (!prop_obj) {
|
|
|
|
ret = -ENOENT;
|
2016-04-23 04:10:28 +08:00
|
|
|
goto out_unref;
|
2013-10-17 18:35:00 +08:00
|
|
|
}
|
2012-05-16 05:09:02 +08:00
|
|
|
property = obj_to_property(prop_obj);
|
|
|
|
|
2014-12-17 07:05:29 +08:00
|
|
|
if (!drm_property_change_valid_get(property, arg->value, &ref))
|
2016-04-27 09:10:09 +08:00
|
|
|
goto out_unref;
|
2012-05-16 05:09:02 +08:00
|
|
|
|
|
|
|
switch (arg_obj->type) {
|
|
|
|
case DRM_MODE_OBJECT_CONNECTOR:
|
|
|
|
ret = drm_mode_connector_set_obj_prop(arg_obj, property,
|
|
|
|
arg->value);
|
|
|
|
break;
|
2012-05-16 05:09:05 +08:00
|
|
|
case DRM_MODE_OBJECT_CRTC:
|
|
|
|
ret = drm_mode_crtc_set_obj_prop(arg_obj, property, arg->value);
|
|
|
|
break;
|
2012-05-17 16:23:27 +08:00
|
|
|
case DRM_MODE_OBJECT_PLANE:
|
2014-08-20 21:45:00 +08:00
|
|
|
ret = drm_mode_plane_set_obj_prop(obj_to_plane(arg_obj),
|
|
|
|
property, arg->value);
|
2012-05-17 16:23:27 +08:00
|
|
|
break;
|
2012-05-16 05:09:02 +08:00
|
|
|
}
|
|
|
|
|
2014-12-17 07:05:29 +08:00
|
|
|
drm_property_change_valid_put(property, ref);
|
|
|
|
|
2016-04-23 04:10:28 +08:00
|
|
|
out_unref:
|
|
|
|
drm_mode_object_unreference(arg_obj);
|
2012-05-16 05:09:02 +08:00
|
|
|
out:
|
2012-12-02 07:28:11 +08:00
|
|
|
drm_modeset_unlock_all(dev);
|
2012-05-16 05:09:02 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-03-11 04:33:02 +08: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:
|
2014-11-20 01:38:09 +08:00
|
|
|
* Zero on success, negative errno on failure.
|
2014-03-11 04:33:02 +08:00
|
|
|
*/
|
2008-11-08 06:05:41 +08:00
|
|
|
int drm_mode_connector_attach_encoder(struct drm_connector *connector,
|
|
|
|
struct drm_encoder *encoder)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2015-11-17 01:19:53 +08:00
|
|
|
/*
|
|
|
|
* In the past, drivers have attempted to model the static association
|
|
|
|
* of connector to encoder in simple connector/encoder devices using a
|
|
|
|
* direct assignment of connector->encoder = encoder. This connection
|
|
|
|
* is a logical one and the responsibility of the core, so drivers are
|
|
|
|
* expected not to mess with this.
|
|
|
|
*
|
|
|
|
* Note that the error return should've been enough here, but a large
|
|
|
|
* majority of drivers ignores the return value, so add in a big WARN
|
|
|
|
* to get people's attention.
|
|
|
|
*/
|
|
|
|
if (WARN_ON(connector->encoder))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2008-11-08 06:05:41 +08:00
|
|
|
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-11 04:33:02 +08: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:
|
2014-11-20 01:38:09 +08:00
|
|
|
* Zero on success, negative errno on failure.
|
2014-03-11 04:33:02 +08:00
|
|
|
*/
|
2012-02-01 18:38:23 +08:00
|
|
|
int drm_mode_crtc_set_gamma_size(struct drm_crtc *crtc,
|
2014-03-11 04:33:02 +08:00
|
|
|
int gamma_size)
|
2008-11-08 06:05:41 +08:00
|
|
|
{
|
2016-03-30 17:51:16 +08:00
|
|
|
uint16_t *r_base, *g_base, *b_base;
|
|
|
|
int i;
|
|
|
|
|
2008-11-08 06:05:41 +08:00
|
|
|
crtc->gamma_size = gamma_size;
|
|
|
|
|
2014-12-10 20:03:35 +08:00
|
|
|
crtc->gamma_store = kcalloc(gamma_size, sizeof(uint16_t) * 3,
|
|
|
|
GFP_KERNEL);
|
2008-11-08 06:05:41 +08:00
|
|
|
if (!crtc->gamma_store) {
|
|
|
|
crtc->gamma_size = 0;
|
2012-02-01 18:38:23 +08:00
|
|
|
return -ENOMEM;
|
2008-11-08 06:05:41 +08:00
|
|
|
}
|
|
|
|
|
2016-03-30 17:51:16 +08:00
|
|
|
r_base = crtc->gamma_store;
|
|
|
|
g_base = r_base + gamma_size;
|
|
|
|
b_base = g_base + gamma_size;
|
|
|
|
for (i = 0; i < gamma_size; i++) {
|
|
|
|
r_base[i] = i << 8;
|
|
|
|
g_base[i] = i << 8;
|
|
|
|
b_base[i] = i << 8;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-02-01 18:38:23 +08:00
|
|
|
return 0;
|
2008-11-08 06:05:41 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_mode_crtc_set_gamma_size);
|
|
|
|
|
2014-03-11 04:33:02 +08: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:
|
2014-11-20 01:38:09 +08:00
|
|
|
* Zero on success, negative errno on failure.
|
2014-03-11 04:33:02 +08:00
|
|
|
*/
|
2008-11-08 06:05:41 +08: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 11:55:21 +08:00
|
|
|
if (!drm_core_check_feature(dev, DRIVER_MODESET))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2012-12-02 07:28:11 +08:00
|
|
|
drm_modeset_lock_all(dev);
|
2013-10-06 04:36:52 +08:00
|
|
|
crtc = drm_crtc_find(dev, crtc_lut->crtc_id);
|
|
|
|
if (!crtc) {
|
2013-10-17 18:35:00 +08:00
|
|
|
ret = -ENOENT;
|
2008-11-08 06:05:41 +08:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2012-05-17 19:27:24 +08:00
|
|
|
if (crtc->funcs->gamma_set == NULL) {
|
|
|
|
ret = -ENOSYS;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2008-11-08 06:05:41 +08: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;
|
|
|
|
}
|
|
|
|
|
2016-06-07 18:49:30 +08:00
|
|
|
ret = crtc->funcs->gamma_set(crtc, r_base, g_base, b_base, crtc->gamma_size);
|
2008-11-08 06:05:41 +08:00
|
|
|
|
|
|
|
out:
|
2012-12-02 07:28:11 +08:00
|
|
|
drm_modeset_unlock_all(dev);
|
2008-11-08 06:05:41 +08:00
|
|
|
return ret;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2014-03-11 04:33:02 +08: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:
|
2014-11-20 01:38:09 +08:00
|
|
|
* Zero on success, negative errno on failure.
|
2014-03-11 04:33:02 +08:00
|
|
|
*/
|
2008-11-08 06:05:41 +08: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 11:55:21 +08:00
|
|
|
if (!drm_core_check_feature(dev, DRIVER_MODESET))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2012-12-02 07:28:11 +08:00
|
|
|
drm_modeset_lock_all(dev);
|
2013-10-06 04:36:52 +08:00
|
|
|
crtc = drm_crtc_find(dev, crtc_lut->crtc_id);
|
|
|
|
if (!crtc) {
|
2013-10-17 18:35:00 +08:00
|
|
|
ret = -ENOENT;
|
2008-11-08 06:05:41 +08: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-02 07:28:11 +08:00
|
|
|
drm_modeset_unlock_all(dev);
|
2008-11-08 06:05:41 +08:00
|
|
|
return ret;
|
|
|
|
}
|
2009-11-18 01:43:55 +08:00
|
|
|
|
2014-03-11 04:33:02 +08: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:
|
2014-11-20 01:38:09 +08:00
|
|
|
* Zero on success, negative errno on failure.
|
2014-03-11 04:33:02 +08:00
|
|
|
*/
|
2009-11-18 01:43:55 +08: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;
|
2014-07-27 19:42:42 +08:00
|
|
|
struct drm_framebuffer *fb = NULL;
|
2009-11-18 01:43:55 +08:00
|
|
|
struct drm_pending_vblank_event *e = NULL;
|
|
|
|
int ret = -EINVAL;
|
|
|
|
|
|
|
|
if (page_flip->flags & ~DRM_MODE_PAGE_FLIP_FLAGS ||
|
|
|
|
page_flip->reserved != 0)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2013-07-23 09:50:00 +08:00
|
|
|
if ((page_flip->flags & DRM_MODE_PAGE_FLIP_ASYNC) && !dev->mode_config.async_page_flip)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2013-10-06 04:36:52 +08:00
|
|
|
crtc = drm_crtc_find(dev, page_flip->crtc_id);
|
|
|
|
if (!crtc)
|
2013-10-17 18:35:00 +08:00
|
|
|
return -ENOENT;
|
2009-11-18 01:43:55 +08:00
|
|
|
|
2014-11-11 17:12:00 +08:00
|
|
|
drm_modeset_lock_crtc(crtc, crtc->primary);
|
2014-04-02 06:22:40 +08:00
|
|
|
if (crtc->primary->fb == NULL) {
|
2010-07-18 03:23:26 +08:00
|
|
|
/* The framebuffer is currently unbound, presumably
|
|
|
|
* due to a hotplug event, that userspace has not
|
|
|
|
* yet discovered.
|
|
|
|
*/
|
|
|
|
ret = -EBUSY;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2009-11-18 01:43:55 +08:00
|
|
|
if (crtc->funcs->page_flip == NULL)
|
|
|
|
goto out;
|
|
|
|
|
2012-12-03 04:53:40 +08:00
|
|
|
fb = drm_framebuffer_lookup(dev, page_flip->fb_id);
|
2013-10-17 18:35:01 +08:00
|
|
|
if (!fb) {
|
|
|
|
ret = -ENOENT;
|
2009-11-18 01:43:55 +08:00
|
|
|
goto out;
|
2013-10-17 18:35:01 +08:00
|
|
|
}
|
2009-11-18 01:43:55 +08:00
|
|
|
|
2015-10-16 01:40:02 +08:00
|
|
|
if (crtc->state) {
|
|
|
|
const struct drm_plane_state *state = crtc->primary->state;
|
|
|
|
|
|
|
|
ret = check_src_coords(state->src_x, state->src_y,
|
|
|
|
state->src_w, state->src_h, fb);
|
|
|
|
} else {
|
|
|
|
ret = drm_crtc_check_viewport(crtc, crtc->x, crtc->y, &crtc->mode, fb);
|
|
|
|
}
|
2013-09-25 23:45:30 +08:00
|
|
|
if (ret)
|
2012-03-13 18:35:45 +08:00
|
|
|
goto out;
|
|
|
|
|
2014-04-02 06:22:40 +08:00
|
|
|
if (crtc->primary->fb->pixel_format != fb->pixel_format) {
|
2013-04-22 07:38:46 +08:00
|
|
|
DRM_DEBUG_KMS("Page flip is not allowed to change frame buffer format.\n");
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2009-11-18 01:43:55 +08:00
|
|
|
if (page_flip->flags & DRM_MODE_PAGE_FLIP_EVENT) {
|
2016-01-12 05:40:56 +08:00
|
|
|
e = kzalloc(sizeof *e, GFP_KERNEL);
|
|
|
|
if (!e) {
|
|
|
|
ret = -ENOMEM;
|
2009-11-18 01:43:55 +08:00
|
|
|
goto out;
|
|
|
|
}
|
2009-11-20 02:50:22 +08:00
|
|
|
e->event.base.type = DRM_EVENT_FLIP_COMPLETE;
|
2014-12-10 20:03:40 +08:00
|
|
|
e->event.base.length = sizeof(e->event);
|
2009-11-18 01:43:55 +08:00
|
|
|
e->event.user_data = page_flip->user_data;
|
2016-01-12 05:40:56 +08:00
|
|
|
ret = drm_event_reserve_init(dev, file_priv, &e->base, &e->event.base);
|
|
|
|
if (ret) {
|
|
|
|
kfree(e);
|
|
|
|
goto out;
|
|
|
|
}
|
2009-11-18 01:43:55 +08:00
|
|
|
}
|
|
|
|
|
2014-07-27 19:42:42 +08:00
|
|
|
crtc->primary->old_fb = crtc->primary->fb;
|
2013-07-23 09:49:58 +08:00
|
|
|
ret = crtc->funcs->page_flip(crtc, fb, e, page_flip->flags);
|
2009-11-18 01:43:55 +08:00
|
|
|
if (ret) {
|
2016-01-12 05:40:56 +08:00
|
|
|
if (page_flip->flags & DRM_MODE_PAGE_FLIP_EVENT)
|
|
|
|
drm_event_cancel_free(dev, &e->base);
|
2012-12-11 08:07:12 +08:00
|
|
|
/* Keep the old fb, don't unref it. */
|
2014-07-27 19:42:42 +08:00
|
|
|
crtc->primary->old_fb = NULL;
|
2012-12-11 08:07:12 +08:00
|
|
|
} else {
|
2015-07-07 14:43:03 +08:00
|
|
|
crtc->primary->fb = fb;
|
2012-12-11 08:07:12 +08:00
|
|
|
/* Unref only the old framebuffer. */
|
|
|
|
fb = NULL;
|
2009-11-18 01:43:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
2012-12-11 08:07:12 +08:00
|
|
|
if (fb)
|
|
|
|
drm_framebuffer_unreference(fb);
|
2014-07-27 19:42:42 +08:00
|
|
|
if (crtc->primary->old_fb)
|
|
|
|
drm_framebuffer_unreference(crtc->primary->old_fb);
|
|
|
|
crtc->primary->old_fb = NULL;
|
2014-07-26 00:07:40 +08:00
|
|
|
drm_modeset_unlock_crtc(crtc);
|
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 23:59:31 +08:00
|
|
|
|
2009-11-18 01:43:55 +08:00
|
|
|
return ret;
|
|
|
|
}
|
2011-01-24 23:11:08 +08:00
|
|
|
|
2014-03-11 04:33:02 +08: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 23:11:08 +08:00
|
|
|
void drm_mode_config_reset(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
struct drm_crtc *crtc;
|
2014-07-29 21:32:37 +08:00
|
|
|
struct drm_plane *plane;
|
2011-01-24 23:11:08 +08:00
|
|
|
struct drm_encoder *encoder;
|
|
|
|
struct drm_connector *connector;
|
|
|
|
|
2015-07-10 05:44:35 +08:00
|
|
|
drm_for_each_plane(plane, dev)
|
2014-07-29 21:32:37 +08:00
|
|
|
if (plane->funcs->reset)
|
|
|
|
plane->funcs->reset(plane);
|
|
|
|
|
2015-07-10 05:44:35 +08:00
|
|
|
drm_for_each_crtc(crtc, dev)
|
2011-01-24 23:11:08 +08:00
|
|
|
if (crtc->funcs->reset)
|
|
|
|
crtc->funcs->reset(crtc);
|
|
|
|
|
2015-07-10 05:44:35 +08:00
|
|
|
drm_for_each_encoder(encoder, dev)
|
2011-01-24 23:11:08 +08:00
|
|
|
if (encoder->funcs->reset)
|
|
|
|
encoder->funcs->reset(encoder);
|
|
|
|
|
2015-07-29 14:32:43 +08:00
|
|
|
mutex_lock(&dev->mode_config.mutex);
|
2015-08-17 12:13:53 +08:00
|
|
|
drm_for_each_connector(connector, dev)
|
2011-01-24 23:11:08 +08:00
|
|
|
if (connector->funcs->reset)
|
|
|
|
connector->funcs->reset(connector);
|
2015-07-29 14:32:43 +08:00
|
|
|
mutex_unlock(&dev->mode_config.mutex);
|
2011-01-24 23:11:08 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_mode_config_reset);
|
2011-02-07 10:16:14 +08:00
|
|
|
|
2014-03-11 04:33:02 +08: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:
|
2014-11-20 01:38:09 +08:00
|
|
|
* Zero on success, negative errno on failure.
|
2014-03-11 04:33:02 +08:00
|
|
|
*/
|
2011-02-07 10:16:14 +08: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-21 03:09:55 +08:00
|
|
|
u32 cpp, stride, size;
|
2011-02-07 10:16:14 +08:00
|
|
|
|
|
|
|
if (!dev->driver->dumb_create)
|
|
|
|
return -ENOSYS;
|
2014-01-21 03:09:55 +08:00
|
|
|
if (!args->width || !args->height || !args->bpp)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
/* overflow checks for 32bit size calculations */
|
2014-08-25 01:23:26 +08:00
|
|
|
/* NOTE: DIV_ROUND_UP() can overflow */
|
2014-01-21 03:09:55 +08:00
|
|
|
cpp = DIV_ROUND_UP(args->bpp, 8);
|
2014-08-25 01:23:26 +08:00
|
|
|
if (!cpp || cpp > 0xffffffffU / args->width)
|
2014-01-21 03:09:55 +08:00
|
|
|
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;
|
|
|
|
|
2014-11-03 18:14:14 +08:00
|
|
|
/*
|
|
|
|
* handle, pitch and size are output parameters. Zero them out to
|
|
|
|
* prevent drivers from accidentally using uninitialized data. Since
|
|
|
|
* not all existing userspace is clearing these fields properly we
|
|
|
|
* cannot reject IOCTL with garbage in them.
|
|
|
|
*/
|
|
|
|
args->handle = 0;
|
|
|
|
args->pitch = 0;
|
|
|
|
args->size = 0;
|
|
|
|
|
2011-02-07 10:16:14 +08:00
|
|
|
return dev->driver->dumb_create(file_priv, dev, args);
|
|
|
|
}
|
|
|
|
|
2014-03-11 04:33:02 +08: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:
|
2014-11-20 01:38:09 +08:00
|
|
|
* Zero on success, negative errno on failure.
|
2014-03-11 04:33:02 +08:00
|
|
|
*/
|
2011-02-07 10:16:14 +08: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-11 04:33:02 +08: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:
|
2014-11-20 01:38:09 +08:00
|
|
|
* Zero on success, negative errno on failure.
|
2014-03-11 04:33:02 +08:00
|
|
|
*/
|
2011-02-07 10:16:14 +08: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-30 04:02:54 +08:00
|
|
|
|
2014-07-08 13:01:56 +08:00
|
|
|
/**
|
|
|
|
* drm_rotation_simplify() - Try to simplify the rotation
|
|
|
|
* @rotation: Rotation to be simplified
|
|
|
|
* @supported_rotations: Supported rotations
|
|
|
|
*
|
|
|
|
* Attempt to simplify the rotation to a form that is supported.
|
|
|
|
* Eg. if the hardware supports everything except DRM_REFLECT_X
|
|
|
|
* one could call this function like this:
|
|
|
|
*
|
2016-07-29 13:50:05 +08:00
|
|
|
* drm_rotation_simplify(rotation, DRM_ROTATE_0 |
|
|
|
|
* DRM_ROTATE_90 | DRM_ROTATE_180 |
|
|
|
|
* DRM_ROTATE_270 | DRM_REFLECT_Y);
|
2014-07-08 13:01:56 +08:00
|
|
|
*
|
|
|
|
* to eliminate the DRM_ROTATE_X flag. Depending on what kind of
|
|
|
|
* transforms the hardware supports, this function may not
|
|
|
|
* be able to produce a supported transform, so the caller should
|
|
|
|
* check the result afterwards.
|
|
|
|
*/
|
|
|
|
unsigned int drm_rotation_simplify(unsigned int rotation,
|
|
|
|
unsigned int supported_rotations)
|
|
|
|
{
|
|
|
|
if (rotation & ~supported_rotations) {
|
2016-07-29 13:50:05 +08:00
|
|
|
rotation ^= DRM_REFLECT_X | DRM_REFLECT_Y;
|
2015-10-01 15:00:58 +08:00
|
|
|
rotation = (rotation & DRM_REFLECT_MASK) |
|
|
|
|
BIT((ffs(rotation & DRM_ROTATE_MASK) + 1) % 4);
|
2014-07-08 13:01:56 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return rotation;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_rotation_simplify);
|
|
|
|
|
2013-04-15 21:37:16 +08: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-20 01:10:12 +08:00
|
|
|
drm_modeset_lock_init(&dev->mode_config.connection_mutex);
|
2013-04-15 21:37:16 +08:00
|
|
|
mutex_init(&dev->mode_config.idr_mutex);
|
|
|
|
mutex_init(&dev->mode_config.fb_lock);
|
2015-04-21 02:22:54 +08:00
|
|
|
mutex_init(&dev->mode_config.blob_lock);
|
2013-04-15 21:37:16 +08:00
|
|
|
INIT_LIST_HEAD(&dev->mode_config.fb_list);
|
|
|
|
INIT_LIST_HEAD(&dev->mode_config.crtc_list);
|
|
|
|
INIT_LIST_HEAD(&dev->mode_config.connector_list);
|
|
|
|
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);
|
2014-10-20 14:17:17 +08:00
|
|
|
idr_init(&dev->mode_config.tile_idr);
|
2016-02-17 15:32:05 +08:00
|
|
|
ida_init(&dev->mode_config.connector_ida);
|
2013-04-15 21:37:16 +08:00
|
|
|
|
|
|
|
drm_modeset_lock_all(dev);
|
2014-12-19 05:01:53 +08:00
|
|
|
drm_mode_create_standard_properties(dev);
|
2013-04-15 21:37:16 +08: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-02 06:22:30 +08:00
|
|
|
dev->mode_config.num_overlay_plane = 0;
|
|
|
|
dev->mode_config.num_total_plane = 0;
|
2013-04-15 21:37:16 +08: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;
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2016-03-22 22:42:14 +08:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2013-04-15 21:37:16 +08:00
|
|
|
list_for_each_entry_safe(blob, bt, &dev->mode_config.property_blob_list,
|
2015-05-22 20:34:51 +08:00
|
|
|
head_global) {
|
2015-04-21 02:22:55 +08:00
|
|
|
drm_property_unreference_blob(blob);
|
2013-04-15 21:37:16 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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) {
|
2016-04-15 13:10:36 +08:00
|
|
|
drm_framebuffer_free(&fb->base.refcount);
|
2013-04-15 21:37:16 +08:00
|
|
|
}
|
|
|
|
|
2016-02-17 15:32:05 +08:00
|
|
|
ida_destroy(&dev->mode_config.connector_ida);
|
2014-10-20 14:17:17 +08:00
|
|
|
idr_destroy(&dev->mode_config.tile_idr);
|
2013-04-15 21:37:16 +08:00
|
|
|
idr_destroy(&dev->mode_config.crtc_idr);
|
2013-11-20 01:10:12 +08:00
|
|
|
drm_modeset_lock_fini(&dev->mode_config.connection_mutex);
|
2013-04-15 21:37:16 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_mode_config_cleanup);
|
2014-07-08 13:01:53 +08:00
|
|
|
|
|
|
|
struct drm_property *drm_mode_create_rotation_property(struct drm_device *dev,
|
|
|
|
unsigned int supported_rotations)
|
|
|
|
{
|
|
|
|
static const struct drm_prop_enum_list props[] = {
|
2016-07-29 13:50:05 +08:00
|
|
|
{ __builtin_ffs(DRM_ROTATE_0) - 1, "rotate-0" },
|
|
|
|
{ __builtin_ffs(DRM_ROTATE_90) - 1, "rotate-90" },
|
|
|
|
{ __builtin_ffs(DRM_ROTATE_180) - 1, "rotate-180" },
|
|
|
|
{ __builtin_ffs(DRM_ROTATE_270) - 1, "rotate-270" },
|
|
|
|
{ __builtin_ffs(DRM_REFLECT_X) - 1, "reflect-x" },
|
|
|
|
{ __builtin_ffs(DRM_REFLECT_Y) - 1, "reflect-y" },
|
2014-07-08 13:01:53 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
return drm_property_create_bitmask(dev, 0, "rotation",
|
|
|
|
props, ARRAY_SIZE(props),
|
|
|
|
supported_rotations);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_mode_create_rotation_property);
|
2014-10-20 14:17:17 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* DOC: Tile group
|
|
|
|
*
|
|
|
|
* Tile groups are used to represent tiled monitors with a unique
|
|
|
|
* integer identifier. Tiled monitors using DisplayID v1.3 have
|
|
|
|
* a unique 8-byte handle, we store this in a tile group, so we
|
|
|
|
* have a common identifier for all tiles in a monitor group.
|
|
|
|
*/
|
|
|
|
static void drm_tile_group_free(struct kref *kref)
|
|
|
|
{
|
|
|
|
struct drm_tile_group *tg = container_of(kref, struct drm_tile_group, refcount);
|
|
|
|
struct drm_device *dev = tg->dev;
|
|
|
|
mutex_lock(&dev->mode_config.idr_mutex);
|
|
|
|
idr_remove(&dev->mode_config.tile_idr, tg->id);
|
|
|
|
mutex_unlock(&dev->mode_config.idr_mutex);
|
|
|
|
kfree(tg);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_mode_put_tile_group - drop a reference to a tile group.
|
|
|
|
* @dev: DRM device
|
|
|
|
* @tg: tile group to drop reference to.
|
|
|
|
*
|
|
|
|
* drop reference to tile group and free if 0.
|
|
|
|
*/
|
|
|
|
void drm_mode_put_tile_group(struct drm_device *dev,
|
|
|
|
struct drm_tile_group *tg)
|
|
|
|
{
|
|
|
|
kref_put(&tg->refcount, drm_tile_group_free);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_mode_get_tile_group - get a reference to an existing tile group
|
|
|
|
* @dev: DRM device
|
|
|
|
* @topology: 8-bytes unique per monitor.
|
|
|
|
*
|
|
|
|
* Use the unique bytes to get a reference to an existing tile group.
|
|
|
|
*
|
|
|
|
* RETURNS:
|
|
|
|
* tile group or NULL if not found.
|
|
|
|
*/
|
|
|
|
struct drm_tile_group *drm_mode_get_tile_group(struct drm_device *dev,
|
|
|
|
char topology[8])
|
|
|
|
{
|
|
|
|
struct drm_tile_group *tg;
|
|
|
|
int id;
|
|
|
|
mutex_lock(&dev->mode_config.idr_mutex);
|
|
|
|
idr_for_each_entry(&dev->mode_config.tile_idr, tg, id) {
|
|
|
|
if (!memcmp(tg->group_data, topology, 8)) {
|
|
|
|
if (!kref_get_unless_zero(&tg->refcount))
|
|
|
|
tg = NULL;
|
|
|
|
mutex_unlock(&dev->mode_config.idr_mutex);
|
|
|
|
return tg;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
mutex_unlock(&dev->mode_config.idr_mutex);
|
|
|
|
return NULL;
|
|
|
|
}
|
2015-03-28 01:01:52 +08:00
|
|
|
EXPORT_SYMBOL(drm_mode_get_tile_group);
|
2014-10-20 14:17:17 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_mode_create_tile_group - create a tile group from a displayid description
|
|
|
|
* @dev: DRM device
|
|
|
|
* @topology: 8-bytes unique per monitor.
|
|
|
|
*
|
|
|
|
* Create a tile group for the unique monitor, and get a unique
|
|
|
|
* identifier for the tile group.
|
|
|
|
*
|
|
|
|
* RETURNS:
|
|
|
|
* new tile group or error.
|
|
|
|
*/
|
|
|
|
struct drm_tile_group *drm_mode_create_tile_group(struct drm_device *dev,
|
|
|
|
char topology[8])
|
|
|
|
{
|
|
|
|
struct drm_tile_group *tg;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
tg = kzalloc(sizeof(*tg), GFP_KERNEL);
|
|
|
|
if (!tg)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
|
|
|
|
kref_init(&tg->refcount);
|
|
|
|
memcpy(tg->group_data, topology, 8);
|
|
|
|
tg->dev = dev;
|
|
|
|
|
|
|
|
mutex_lock(&dev->mode_config.idr_mutex);
|
|
|
|
ret = idr_alloc(&dev->mode_config.tile_idr, tg, 1, 0, GFP_KERNEL);
|
|
|
|
if (ret >= 0) {
|
|
|
|
tg->id = ret;
|
|
|
|
} else {
|
|
|
|
kfree(tg);
|
|
|
|
tg = ERR_PTR(ret);
|
|
|
|
}
|
|
|
|
|
|
|
|
mutex_unlock(&dev->mode_config.idr_mutex);
|
|
|
|
return tg;
|
|
|
|
}
|
2015-03-28 01:01:52 +08:00
|
|
|
EXPORT_SYMBOL(drm_mode_create_tile_group);
|
2016-06-07 20:09:14 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_crtc_enable_color_mgmt - enable color management properties
|
|
|
|
* @crtc: DRM CRTC
|
|
|
|
* @degamma_lut_size: the size of the degamma lut (before CSC)
|
|
|
|
* @has_ctm: whether to attach ctm_property for CSC matrix
|
|
|
|
* @gamma_lut_size: the size of the gamma lut (after CSC)
|
|
|
|
*
|
|
|
|
* This function lets the driver enable the color correction
|
|
|
|
* properties on a CRTC. This includes 3 degamma, csc and gamma
|
|
|
|
* properties that userspace can set and 2 size properties to inform
|
|
|
|
* the userspace of the lut sizes. Each of the properties are
|
|
|
|
* optional. The gamma and degamma properties are only attached if
|
|
|
|
* their size is not 0 and ctm_property is only attached if has_ctm is
|
|
|
|
* true.
|
|
|
|
*/
|
|
|
|
void drm_crtc_enable_color_mgmt(struct drm_crtc *crtc,
|
|
|
|
uint degamma_lut_size,
|
|
|
|
bool has_ctm,
|
|
|
|
uint gamma_lut_size)
|
|
|
|
{
|
|
|
|
struct drm_device *dev = crtc->dev;
|
|
|
|
struct drm_mode_config *config = &dev->mode_config;
|
|
|
|
|
|
|
|
if (degamma_lut_size) {
|
|
|
|
drm_object_attach_property(&crtc->base,
|
|
|
|
config->degamma_lut_property, 0);
|
|
|
|
drm_object_attach_property(&crtc->base,
|
|
|
|
config->degamma_lut_size_property,
|
|
|
|
degamma_lut_size);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (has_ctm)
|
|
|
|
drm_object_attach_property(&crtc->base,
|
|
|
|
config->ctm_property, 0);
|
|
|
|
|
|
|
|
if (gamma_lut_size) {
|
|
|
|
drm_object_attach_property(&crtc->base,
|
|
|
|
config->gamma_lut_property, 0);
|
|
|
|
drm_object_attach_property(&crtc->base,
|
|
|
|
config->gamma_lut_size_property,
|
|
|
|
gamma_lut_size);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_crtc_enable_color_mgmt);
|