WebSVN – Kolibri OS – Blame – /drivers/video/drm/drm_crtc.c

Rev	Author	Line No.	Line
1123	serge	1	/*
		2	* Copyright (c) 2006-2008 Intel Corporation
		3	* Copyright (c) 2007 Dave Airlie
		4	* Copyright (c) 2008 Red Hat Inc.
		5	*
		6	* DRM core CRTC related functions
		7	*
		8	* Permission to use, copy, modify, distribute, and sell this software and its
		9	* documentation for any purpose is hereby granted without fee, provided that
		10	* the above copyright notice appear in all copies and that both that copyright
		11	* notice and this permission notice appear in supporting documentation, and
		12	* that the name of the copyright holders not be used in advertising or
		13	* publicity pertaining to distribution of the software without specific,
		14	* written prior permission. The copyright holders make no representations
		15	* about the suitability of this software for any purpose. It is provided "as
		16	* is" without express or implied warranty.
		17	*
		18	* THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
		19	* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
		20	* EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
		21	* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
		22	* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
		23	* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
		24	* OF THIS SOFTWARE.
		25	*
		26	* Authors:
		27	* Keith Packard
		28	* Eric Anholt
		29	* Dave Airlie
		30	* Jesse Barnes
		31	*/
4075	Serge	32	#include
1179	serge	33	#include
1963	serge	34	#include
3031	serge	35	#include
		36	#include
		37	#include
		38	#include
		39	#include
5060	serge	40	#include
6084	serge	41	#include
1123	serge	42
5060	serge	43	#include "drm_crtc_internal.h"
5271	serge	44	#include "drm_internal.h"
5060	serge	45
6084	serge	46	static struct drm_framebuffer *
		47	internal_framebuffer_create(struct drm_device *dev,
6937	serge	48	const struct drm_mode_fb_cmd2 *r,
6084	serge	49	struct drm_file *file_priv);
5060	serge	50
1123	serge	51	/* Avoid boilerplate. I'm tired of typing. */
		52	#define DRM_ENUM_NAME_FN(fnname, list) \
4075	Serge	53	const char *fnname(int val) \
1123	serge	54	{ \
		55	int i; \
		56	for (i = 0; i < ARRAY_SIZE(list); i++) { \
		57	if (list[i].type == val) \
		58	return list[i].name; \
		59	} \
		60	return "(unknown)"; \
		61	}
		62
		63	/*
		64	* Global properties
		65	*/
6084	serge	66	static const struct drm_prop_enum_list drm_dpms_enum_list[] = {
		67	{ DRM_MODE_DPMS_ON, "On" },
1123	serge	68	{ DRM_MODE_DPMS_STANDBY, "Standby" },
		69	{ DRM_MODE_DPMS_SUSPEND, "Suspend" },
		70	{ DRM_MODE_DPMS_OFF, "Off" }
		71	};
		72
		73	DRM_ENUM_NAME_FN(drm_get_dpms_name, drm_dpms_enum_list)
		74
6084	serge	75	static const struct drm_prop_enum_list drm_plane_type_enum_list[] = {
5060	serge	76	{ DRM_PLANE_TYPE_OVERLAY, "Overlay" },
		77	{ DRM_PLANE_TYPE_PRIMARY, "Primary" },
		78	{ DRM_PLANE_TYPE_CURSOR, "Cursor" },
		79	};
		80
1123	serge	81	/*
		82	* Optional properties
		83	*/
6084	serge	84	static const struct drm_prop_enum_list drm_scaling_mode_enum_list[] = {
1179	serge	85	{ DRM_MODE_SCALE_NONE, "None" },
		86	{ DRM_MODE_SCALE_FULLSCREEN, "Full" },
		87	{ DRM_MODE_SCALE_CENTER, "Center" },
		88	{ DRM_MODE_SCALE_ASPECT, "Full aspect" },
1123	serge	89	};
		90
5060	serge	91	static const struct drm_prop_enum_list drm_aspect_ratio_enum_list[] = {
		92	{ DRM_MODE_PICTURE_ASPECT_NONE, "Automatic" },
		93	{ DRM_MODE_PICTURE_ASPECT_4_3, "4:3" },
		94	{ DRM_MODE_PICTURE_ASPECT_16_9, "16:9" },
		95	};
		96
1123	serge	97	/*
		98	* Non-global properties, but "required" for certain connectors.
		99	*/
6084	serge	100	static const struct drm_prop_enum_list drm_dvi_i_select_enum_list[] = {
1123	serge	101	{ DRM_MODE_SUBCONNECTOR_Automatic, "Automatic" }, /* DVI-I and TV-out */
		102	{ DRM_MODE_SUBCONNECTOR_DVID, "DVI-D" }, /* DVI-I */
		103	{ DRM_MODE_SUBCONNECTOR_DVIA, "DVI-A" }, /* DVI-I */
		104	};
		105
		106	DRM_ENUM_NAME_FN(drm_get_dvi_i_select_name, drm_dvi_i_select_enum_list)
		107
6084	serge	108	static const struct drm_prop_enum_list drm_dvi_i_subconnector_enum_list[] = {
1123	serge	109	{ DRM_MODE_SUBCONNECTOR_Unknown, "Unknown" }, /* DVI-I and TV-out */
		110	{ DRM_MODE_SUBCONNECTOR_DVID, "DVI-D" }, /* DVI-I */
		111	{ DRM_MODE_SUBCONNECTOR_DVIA, "DVI-A" }, /* DVI-I */
		112	};
		113
		114	DRM_ENUM_NAME_FN(drm_get_dvi_i_subconnector_name,
		115	drm_dvi_i_subconnector_enum_list)
		116
6084	serge	117	static const struct drm_prop_enum_list drm_tv_select_enum_list[] = {
1123	serge	118	{ DRM_MODE_SUBCONNECTOR_Automatic, "Automatic" }, /* DVI-I and TV-out */
		119	{ DRM_MODE_SUBCONNECTOR_Composite, "Composite" }, /* TV-out */
		120	{ DRM_MODE_SUBCONNECTOR_SVIDEO, "SVIDEO" }, /* TV-out */
		121	{ DRM_MODE_SUBCONNECTOR_Component, "Component" }, /* TV-out */
1179	serge	122	{ DRM_MODE_SUBCONNECTOR_SCART, "SCART" }, /* TV-out */
1123	serge	123	};
		124
		125	DRM_ENUM_NAME_FN(drm_get_tv_select_name, drm_tv_select_enum_list)
		126
6084	serge	127	static const struct drm_prop_enum_list drm_tv_subconnector_enum_list[] = {
1123	serge	128	{ DRM_MODE_SUBCONNECTOR_Unknown, "Unknown" }, /* DVI-I and TV-out */
		129	{ DRM_MODE_SUBCONNECTOR_Composite, "Composite" }, /* TV-out */
		130	{ DRM_MODE_SUBCONNECTOR_SVIDEO, "SVIDEO" }, /* TV-out */
		131	{ DRM_MODE_SUBCONNECTOR_Component, "Component" }, /* TV-out */
1179	serge	132	{ DRM_MODE_SUBCONNECTOR_SCART, "SCART" }, /* TV-out */
1123	serge	133	};
		134
		135	DRM_ENUM_NAME_FN(drm_get_tv_subconnector_name,
		136	drm_tv_subconnector_enum_list)
		137
4075	Serge	138	static const struct drm_prop_enum_list drm_dirty_info_enum_list[] = {
1321	serge	139	{ DRM_MODE_DIRTY_OFF, "Off" },
		140	{ DRM_MODE_DIRTY_ON, "On" },
		141	{ DRM_MODE_DIRTY_ANNOTATE, "Annotate" },
		142	};
		143
1123	serge	144	struct drm_conn_prop_enum_list {
		145	int type;
4075	Serge	146	const char *name;
4104	Serge	147	struct ida ida;
1123	serge	148	};
		149
		150	/*
		151	* Connector and encoder types.
		152	*/
6084	serge	153	static struct drm_conn_prop_enum_list drm_connector_enum_list[] = {
		154	{ DRM_MODE_CONNECTOR_Unknown, "Unknown" },
4104	Serge	155	{ DRM_MODE_CONNECTOR_VGA, "VGA" },
		156	{ DRM_MODE_CONNECTOR_DVII, "DVI-I" },
		157	{ DRM_MODE_CONNECTOR_DVID, "DVI-D" },
		158	{ DRM_MODE_CONNECTOR_DVIA, "DVI-A" },
		159	{ DRM_MODE_CONNECTOR_Composite, "Composite" },
		160	{ DRM_MODE_CONNECTOR_SVIDEO, "SVIDEO" },
		161	{ DRM_MODE_CONNECTOR_LVDS, "LVDS" },
		162	{ DRM_MODE_CONNECTOR_Component, "Component" },
		163	{ DRM_MODE_CONNECTOR_9PinDIN, "DIN" },
		164	{ DRM_MODE_CONNECTOR_DisplayPort, "DP" },
		165	{ DRM_MODE_CONNECTOR_HDMIA, "HDMI-A" },
		166	{ DRM_MODE_CONNECTOR_HDMIB, "HDMI-B" },
		167	{ DRM_MODE_CONNECTOR_TV, "TV" },
		168	{ DRM_MODE_CONNECTOR_eDP, "eDP" },
		169	{ DRM_MODE_CONNECTOR_VIRTUAL, "Virtual" },
4560	Serge	170	{ DRM_MODE_CONNECTOR_DSI, "DSI" },
1123	serge	171	};
		172
6084	serge	173	static const struct drm_prop_enum_list drm_encoder_enum_list[] = {
		174	{ DRM_MODE_ENCODER_NONE, "None" },
1123	serge	175	{ DRM_MODE_ENCODER_DAC, "DAC" },
		176	{ DRM_MODE_ENCODER_TMDS, "TMDS" },
		177	{ DRM_MODE_ENCODER_LVDS, "LVDS" },
		178	{ DRM_MODE_ENCODER_TVDAC, "TV" },
3031	serge	179	{ DRM_MODE_ENCODER_VIRTUAL, "Virtual" },
4560	Serge	180	{ DRM_MODE_ENCODER_DSI, "DSI" },
5060	serge	181	{ DRM_MODE_ENCODER_DPMST, "DP MST" },
1123	serge	182	};
		183
6084	serge	184	static const struct drm_prop_enum_list drm_subpixel_enum_list[] = {
5060	serge	185	{ SubPixelUnknown, "Unknown" },
		186	{ SubPixelHorizontalRGB, "Horizontal RGB" },
		187	{ SubPixelHorizontalBGR, "Horizontal BGR" },
		188	{ SubPixelVerticalRGB, "Vertical RGB" },
		189	{ SubPixelVerticalBGR, "Vertical BGR" },
		190	{ SubPixelNone, "None" },
		191	};
		192
4104	Serge	193	void drm_connector_ida_init(void)
		194	{
		195	int i;
		196
		197	for (i = 0; i < ARRAY_SIZE(drm_connector_enum_list); i++)
		198	ida_init(&drm_connector_enum_list[i].ida);
		199	}
		200
		201	void drm_connector_ida_destroy(void)
		202	{
		203	int i;
		204
		205	for (i = 0; i < ARRAY_SIZE(drm_connector_enum_list); i++)
		206	ida_destroy(&drm_connector_enum_list[i].ida);
		207	}
		208
5060	serge	209	/**
		210	* drm_get_connector_status_name - return a string for connector status
		211	* @status: connector status to compute name of
		212	*
		213	* In contrast to the other drm_get_*_name functions this one here returns a
		214	* const pointer and hence is threadsafe.
		215	*/
4075	Serge	216	const char *drm_get_connector_status_name(enum drm_connector_status status)
1123	serge	217	{
		218	if (status == connector_status_connected)
		219	return "connected";
		220	else if (status == connector_status_disconnected)
		221	return "disconnected";
		222	else
		223	return "unknown";
		224	}
3764	Serge	225	EXPORT_SYMBOL(drm_get_connector_status_name);
1123	serge	226
5060	serge	227	/**
		228	* drm_get_subpixel_order_name - return a string for a given subpixel enum
		229	* @order: enum of subpixel_order
		230	*
		231	* Note you could abuse this and return something out of bounds, but that
		232	* would be a caller error. No unscrubbed user data should make it here.
		233	*/
		234	const char *drm_get_subpixel_order_name(enum subpixel_order order)
		235	{
		236	return drm_subpixel_enum_list[order].name;
		237	}
		238	EXPORT_SYMBOL(drm_get_subpixel_order_name);
		239
4075	Serge	240	static char printable_char(int c)
		241	{
		242	return isascii(c) && isprint(c) ? c : '?';
		243	}
		244
5060	serge	245	/**
		246	* drm_get_format_name - return a string for drm fourcc format
		247	* @format: format to compute name of
		248	*
		249	* Note that the buffer used by this function is globally shared and owned by
		250	* the function itself.
		251	*
		252	* FIXME: This isn't really multithreading safe.
		253	*/
4075	Serge	254	const char *drm_get_format_name(uint32_t format)
		255	{
		256	static char buf[32];
		257
		258	snprintf(buf, sizeof(buf),
		259	"%c%c%c%c %s-endian (0x%08x)",
		260	printable_char(format & 0xff),
		261	printable_char((format >> 8) & 0xff),
		262	printable_char((format >> 16) & 0xff),
		263	printable_char((format >> 24) & 0x7f),
		264	format & DRM_FORMAT_BIG_ENDIAN ? "big" : "little",
		265	format);
		266
		267	return buf;
		268	}
		269	EXPORT_SYMBOL(drm_get_format_name);
		270
5060	serge	271	/*
		272	* Internal function to assign a slot in the object idr and optionally
		273	* register the object into the idr.
1123	serge	274	*/
5060	serge	275	static int drm_mode_object_get_reg(struct drm_device *dev,
		276	struct drm_mode_object *obj,
		277	uint32_t obj_type,
		278	bool register_obj)
1123	serge	279	{
		280	int ret;
		281
3480	Serge	282	mutex_lock(&dev->mode_config.idr_mutex);
5060	serge	283	ret = idr_alloc(&dev->mode_config.crtc_idr, register_obj ? obj : NULL, 1, 0, GFP_KERNEL);
3480	Serge	284	if (ret >= 0) {
		285	/*
		286	* Set up the object linking under the protection of the idr
		287	* lock so that other users can't see inconsistent state.
		288	*/
		289	obj->id = ret;
		290	obj->type = obj_type;
1123	serge	291	}
1179	serge	292	mutex_unlock(&dev->mode_config.idr_mutex);
1123	serge	293
3480	Serge	294	return ret < 0 ? ret : 0;
1123	serge	295	}
		296
		297	/**
5060	serge	298	* drm_mode_object_get - allocate a new modeset identifier
		299	* @dev: DRM device
		300	* @obj: object pointer, used to generate unique ID
		301	* @obj_type: object type
		302	*
		303	* Create a unique identifier based on @ptr in @dev's identifier space. Used
		304	* for tracking modes, CRTCs and connectors. Note that despite the _get postfix
		305	* modeset identifiers are _not_ reference counted. Hence don't use this for
		306	* reference counted modeset objects like framebuffers.
		307	*
		308	* Returns:
6084	serge	309	* Zero on success, error code on failure.
5060	serge	310	*/
		311	int drm_mode_object_get(struct drm_device *dev,
6084	serge	312	struct drm_mode_object *obj, uint32_t obj_type)
5060	serge	313	{
		314	return drm_mode_object_get_reg(dev, obj, obj_type, true);
		315	}
		316
		317	static void drm_mode_object_register(struct drm_device *dev,
		318	struct drm_mode_object *obj)
		319	{
		320	mutex_lock(&dev->mode_config.idr_mutex);
		321	idr_replace(&dev->mode_config.crtc_idr, obj, obj->id);
		322	mutex_unlock(&dev->mode_config.idr_mutex);
		323	}
		324
		325	/**
3480	Serge	326	* drm_mode_object_put - free a modeset identifer
1123	serge	327	* @dev: DRM device
3480	Serge	328	* @object: object to free
1123	serge	329	*
5060	serge	330	* Free @id from @dev's unique identifier pool. Note that despite the _get
		331	* postfix modeset identifiers are _not_ reference counted. Hence don't use this
		332	* for reference counted modeset objects like framebuffers.
1123	serge	333	*/
5060	serge	334	void drm_mode_object_put(struct drm_device *dev,
6084	serge	335	struct drm_mode_object *object)
1123	serge	336	{
1179	serge	337	mutex_lock(&dev->mode_config.idr_mutex);
1123	serge	338	idr_remove(&dev->mode_config.crtc_idr, object->id);
1179	serge	339	mutex_unlock(&dev->mode_config.idr_mutex);
1123	serge	340	}
		341
5060	serge	342	static struct drm_mode_object _object_find(struct drm_device dev,
		343	uint32_t id, uint32_t type)
		344	{
		345	struct drm_mode_object *obj = NULL;
		346
		347	mutex_lock(&dev->mode_config.idr_mutex);
		348	obj = idr_find(&dev->mode_config.crtc_idr, id);
		349	if (obj && type != DRM_MODE_OBJECT_ANY && obj->type != type)
		350	obj = NULL;
		351	if (obj && obj->id != id)
		352	obj = NULL;
		353	/* don't leak out unref'd fb's */
6084	serge	354	if (obj &&
		355	(obj->type == DRM_MODE_OBJECT_FB \|\|
		356	obj->type == DRM_MODE_OBJECT_BLOB))
5060	serge	357	obj = NULL;
		358	mutex_unlock(&dev->mode_config.idr_mutex);
		359
		360	return obj;
		361	}
		362
3480	Serge	363	/**
		364	* drm_mode_object_find - look up a drm object with static lifetime
		365	* @dev: drm device
		366	* @id: id of the mode object
		367	* @type: type of the mode object
		368	*
		369	* Note that framebuffers cannot be looked up with this functions - since those
5060	serge	370	* are reference counted, they need special treatment. Even with
		371	* DRM_MODE_OBJECT_ANY (although that will simply return NULL
		372	* rather than WARN_ON()).
3480	Serge	373	*/
1321	serge	374	struct drm_mode_object drm_mode_object_find(struct drm_device dev,
		375	uint32_t id, uint32_t type)
1123	serge	376	{
		377	struct drm_mode_object *obj = NULL;
		378
3480	Serge	379	/* Framebuffers are reference counted and need their own lookup
		380	* function.*/
6084	serge	381	WARN_ON(type == DRM_MODE_OBJECT_FB \|\| type == DRM_MODE_OBJECT_BLOB);
5060	serge	382	obj = _object_find(dev, id, type);
1123	serge	383	return obj;
		384	}
		385	EXPORT_SYMBOL(drm_mode_object_find);
		386
		387	/**
		388	* drm_framebuffer_init - initialize a framebuffer
		389	* @dev: DRM device
3480	Serge	390	* @fb: framebuffer to be initialized
		391	* @funcs: ... with these functions
1123	serge	392	*
		393	* Allocates an ID for the framebuffer's parent mode object, sets its mode
		394	* functions & device file and adds it to the master fd list.
		395	*
3480	Serge	396	* IMPORTANT:
		397	* This functions publishes the fb and makes it available for concurrent access
		398	* by other users. Which means by this point the fb _must_ be fully set up -
		399	* since all the fb attributes are invariant over its lifetime, no further
		400	* locking but only correct reference counting is required.
		401	*
5060	serge	402	* Returns:
1321	serge	403	* Zero on success, error code on failure.
1123	serge	404	*/
		405	int drm_framebuffer_init(struct drm_device dev, struct drm_framebuffer fb,
		406	const struct drm_framebuffer_funcs *funcs)
		407	{
		408	int ret;
1963	serge	409
3480	Serge	410	mutex_lock(&dev->mode_config.fb_lock);
		411	kref_init(&fb->refcount);
		412	INIT_LIST_HEAD(&fb->filp_head);
		413	fb->dev = dev;
		414	fb->funcs = funcs;
		415
1123	serge	416	ret = drm_mode_object_get(dev, &fb->base, DRM_MODE_OBJECT_FB);
3031	serge	417	if (ret)
3480	Serge	418	goto out;
1123	serge	419
		420	dev->mode_config.num_fb++;
		421	list_add(&fb->head, &dev->mode_config.fb_list);
3480	Serge	422	out:
		423	mutex_unlock(&dev->mode_config.fb_lock);
1123	serge	424
6084	serge	425	return ret;
1123	serge	426	}
		427	EXPORT_SYMBOL(drm_framebuffer_init);
		428
5271	serge	429	/* dev->mode_config.fb_lock must be held! */
		430	static void __drm_framebuffer_unregister(struct drm_device *dev,
		431	struct drm_framebuffer *fb)
		432	{
		433	mutex_lock(&dev->mode_config.idr_mutex);
		434	idr_remove(&dev->mode_config.crtc_idr, fb->base.id);
		435	mutex_unlock(&dev->mode_config.idr_mutex);
		436
		437	fb->base.id = 0;
		438	}
		439
3480	Serge	440	static void drm_framebuffer_free(struct kref *kref)
		441	{
		442	struct drm_framebuffer *fb =
		443	container_of(kref, struct drm_framebuffer, refcount);
5271	serge	444	struct drm_device *dev = fb->dev;
		445
		446	/*
		447	* The lookup idr holds a weak reference, which has not necessarily been
		448	* removed at this point. Check for that.
		449	*/
		450	mutex_lock(&dev->mode_config.fb_lock);
		451	if (fb->base.id) {
		452	/* Mark fb as reaped and drop idr ref. */
		453	__drm_framebuffer_unregister(dev, fb);
		454	}
		455	mutex_unlock(&dev->mode_config.fb_lock);
		456
3480	Serge	457	fb->funcs->destroy(fb);
		458	}
		459
		460	static struct drm_framebuffer __drm_framebuffer_lookup(struct drm_device dev,
		461	uint32_t id)
		462	{
		463	struct drm_mode_object *obj = NULL;
		464	struct drm_framebuffer *fb;
		465
		466	mutex_lock(&dev->mode_config.idr_mutex);
		467	obj = idr_find(&dev->mode_config.crtc_idr, id);
		468	if (!obj \|\| (obj->type != DRM_MODE_OBJECT_FB) \|\| (obj->id != id))
		469	fb = NULL;
		470	else
		471	fb = obj_to_fb(obj);
		472	mutex_unlock(&dev->mode_config.idr_mutex);
		473
		474	return fb;
		475	}
		476
1123	serge	477	/**
3480	Serge	478	* drm_framebuffer_lookup - look up a drm framebuffer and grab a reference
		479	* @dev: drm device
		480	* @id: id of the fb object
		481	*
		482	* If successful, this grabs an additional reference to the framebuffer -
		483	* callers need to make sure to eventually unreference the returned framebuffer
5060	serge	484	* again, using @drm_framebuffer_unreference.
3480	Serge	485	*/
		486	struct drm_framebuffer drm_framebuffer_lookup(struct drm_device dev,
		487	uint32_t id)
		488	{
		489	struct drm_framebuffer *fb;
		490
		491	mutex_lock(&dev->mode_config.fb_lock);
		492	fb = __drm_framebuffer_lookup(dev, id);
6084	serge	493	if (fb) {
		494	if (!kref_get_unless_zero(&fb->refcount))
		495	fb = NULL;
		496	}
3480	Serge	497	mutex_unlock(&dev->mode_config.fb_lock);
		498
		499	return fb;
		500	}
		501	EXPORT_SYMBOL(drm_framebuffer_lookup);
		502
		503	/**
		504	* drm_framebuffer_unreference - unref a framebuffer
		505	* @fb: framebuffer to unref
		506	*
		507	* This functions decrements the fb's refcount and frees it if it drops to zero.
		508	*/
		509	void drm_framebuffer_unreference(struct drm_framebuffer *fb)
		510	{
5060	serge	511	DRM_DEBUG("%p: FB ID: %d (%d)\n", fb, fb->base.id, atomic_read(&fb->refcount.refcount));
3480	Serge	512	kref_put(&fb->refcount, drm_framebuffer_free);
		513	}
		514	EXPORT_SYMBOL(drm_framebuffer_unreference);
		515
		516	/**
		517	* drm_framebuffer_reference - incr the fb refcnt
		518	* @fb: framebuffer
5060	serge	519	*
		520	* This functions increments the fb's refcount.
3480	Serge	521	*/
		522	void drm_framebuffer_reference(struct drm_framebuffer *fb)
		523	{
5060	serge	524	DRM_DEBUG("%p: FB ID: %d (%d)\n", fb, fb->base.id, atomic_read(&fb->refcount.refcount));
3480	Serge	525	kref_get(&fb->refcount);
		526	}
		527	EXPORT_SYMBOL(drm_framebuffer_reference);
		528
		529	/**
		530	* drm_framebuffer_unregister_private - unregister a private fb from the lookup idr
		531	* @fb: fb to unregister
		532	*
		533	* Drivers need to call this when cleaning up driver-private framebuffers, e.g.
		534	* those used for fbdev. Note that the caller must hold a reference of it's own,
		535	* i.e. the object may not be destroyed through this call (since it'll lead to a
		536	* locking inversion).
		537	*/
		538	void drm_framebuffer_unregister_private(struct drm_framebuffer *fb)
		539	{
6084	serge	540	struct drm_device *dev;
3480	Serge	541
6084	serge	542	if (!fb)
		543	return;
		544
		545	dev = fb->dev;
		546
3480	Serge	547	mutex_lock(&dev->mode_config.fb_lock);
		548	/* Mark fb as reaped and drop idr ref. */
		549	__drm_framebuffer_unregister(dev, fb);
		550	mutex_unlock(&dev->mode_config.fb_lock);
		551	}
		552	EXPORT_SYMBOL(drm_framebuffer_unregister_private);
		553
		554	/**
1123	serge	555	* drm_framebuffer_cleanup - remove a framebuffer object
		556	* @fb: framebuffer to remove
		557	*
5060	serge	558	* Cleanup framebuffer. This function is intended to be used from the drivers
		559	* ->destroy callback. It can also be used to clean up driver private
		560	* framebuffers embedded into a larger structure.
1123	serge	561	*
3480	Serge	562	* Note that this function does not remove the fb from active usuage - if it is
		563	* still used anywhere, hilarity can ensue since userspace could call getfb on
		564	* the id and get back -EINVAL. Obviously no concern at driver unload time.
		565	*
		566	* Also, the framebuffer will not be removed from the lookup idr - for
		567	* user-created framebuffers this will happen in in the rmfb ioctl. For
		568	* driver-private objects (e.g. for fbdev) drivers need to explicitly call
		569	* drm_framebuffer_unregister_private.
1123	serge	570	*/
		571	void drm_framebuffer_cleanup(struct drm_framebuffer *fb)
		572	{
		573	struct drm_device *dev = fb->dev;
3480	Serge	574
		575	mutex_lock(&dev->mode_config.fb_lock);
1123	serge	576	list_del(&fb->head);
		577	dev->mode_config.num_fb--;
3480	Serge	578	mutex_unlock(&dev->mode_config.fb_lock);
1123	serge	579	}
		580	EXPORT_SYMBOL(drm_framebuffer_cleanup);
		581
3480	Serge	582	/**
		583	* drm_framebuffer_remove - remove and unreference a framebuffer object
		584	* @fb: framebuffer to remove
		585	*
		586	* Scans all the CRTCs and planes in @dev's mode_config. If they're
		587	* using @fb, removes it, setting it to NULL. Then drops the reference to the
		588	* passed-in framebuffer. Might take the modeset locks.
		589	*
		590	* Note that this function optimizes the cleanup away if the caller holds the
		591	* last reference to the framebuffer. It is also guaranteed to not take the
		592	* modeset locks in this case.
		593	*/
		594	void drm_framebuffer_remove(struct drm_framebuffer *fb)
		595	{
6084	serge	596	struct drm_device *dev;
3480	Serge	597	struct drm_crtc *crtc;
		598	struct drm_plane *plane;
		599	struct drm_mode_set set;
		600	int ret;
3031	serge	601
6084	serge	602	if (!fb)
		603	return;
		604
		605	dev = fb->dev;
		606
3480	Serge	607	WARN_ON(!list_empty(&fb->filp_head));
3031	serge	608
3480	Serge	609	/*
		610	* drm ABI mandates that we remove any deleted framebuffers from active
		611	* useage. But since most sane clients only remove framebuffers they no
		612	* longer need, try to optimize this away.
		613	*
		614	* Since we're holding a reference ourselves, observing a refcount of 1
		615	* means that we're the last holder and can skip it. Also, the refcount
		616	* can never increase from 1 again, so we don't need any barriers or
		617	* locks.
		618	*
		619	* Note that userspace could try to race with use and instate a new
		620	* usage _after_ we've cleared all current ones. End result will be an
		621	* in-use fb with fb-id == 0. Userspace is allowed to shoot its own foot
		622	* in this manner.
		623	*/
		624	if (atomic_read(&fb->refcount.refcount) > 1) {
		625	drm_modeset_lock_all(dev);
		626	/* remove from any CRTC */
6084	serge	627	drm_for_each_crtc(crtc, dev) {
5060	serge	628	if (crtc->primary->fb == fb) {
3480	Serge	629	/* should turn off the crtc */
		630	memset(&set, 0, sizeof(struct drm_mode_set));
		631	set.crtc = crtc;
		632	set.fb = NULL;
		633	ret = drm_mode_set_config_internal(&set);
		634	if (ret)
		635	DRM_ERROR("failed to reset crtc %p when fb was deleted\n", crtc);
		636	}
		637	}
3031	serge	638
6084	serge	639	drm_for_each_plane(plane, dev) {
4075	Serge	640	if (plane->fb == fb)
		641	drm_plane_force_disable(plane);
3480	Serge	642	}
		643	drm_modeset_unlock_all(dev);
		644	}
3031	serge	645
3480	Serge	646	drm_framebuffer_unreference(fb);
		647	}
		648	EXPORT_SYMBOL(drm_framebuffer_remove);
		649
5060	serge	650	DEFINE_WW_CLASS(crtc_ww_class);
		651
6937	serge	652	static unsigned int drm_num_crtcs(struct drm_device *dev)
		653	{
		654	unsigned int num = 0;
		655	struct drm_crtc *tmp;
		656
		657	drm_for_each_crtc(tmp, dev) {
		658	num++;
		659	}
		660
		661	return num;
		662	}
		663
1123	serge	664	/**
5060	serge	665	* drm_crtc_init_with_planes - Initialise a new CRTC object with
		666	* specified primary and cursor planes.
1123	serge	667	* @dev: DRM device
		668	* @crtc: CRTC object to init
5060	serge	669	* @primary: Primary plane for CRTC
		670	* @cursor: Cursor plane for CRTC
1123	serge	671	* @funcs: callbacks for the new CRTC
6937	serge	672	* @name: printf style format string for the CRTC name, or NULL for default name
1123	serge	673	*
4075	Serge	674	* Inits a new object created as base part of a driver crtc object.
3031	serge	675	*
5060	serge	676	* Returns:
3031	serge	677	* Zero on success, error code on failure.
1123	serge	678	*/
5060	serge	679	int drm_crtc_init_with_planes(struct drm_device dev, struct drm_crtc crtc,
		680	struct drm_plane *primary,
		681	struct drm_plane *cursor,
6937	serge	682	const struct drm_crtc_funcs *funcs,
		683	const char *name, ...)
1123	serge	684	{
5060	serge	685	struct drm_mode_config *config = &dev->mode_config;
3031	serge	686	int ret;
		687
6084	serge	688	WARN_ON(primary && primary->type != DRM_PLANE_TYPE_PRIMARY);
		689	WARN_ON(cursor && cursor->type != DRM_PLANE_TYPE_CURSOR);
		690
1123	serge	691	crtc->dev = dev;
		692	crtc->funcs = funcs;
		693
5060	serge	694	drm_modeset_lock_init(&crtc->mutex);
3031	serge	695	ret = drm_mode_object_get(dev, &crtc->base, DRM_MODE_OBJECT_CRTC);
		696	if (ret)
5271	serge	697	return ret;
3031	serge	698
6937	serge	699	if (name) {
		700	va_list ap;
		701
		702	va_start(ap, name);
		703	crtc->name = kvasprintf(GFP_KERNEL, name, ap);
		704	va_end(ap);
		705	} else {
		706	crtc->name = kasprintf(GFP_KERNEL, "crtc-%d",
		707	drm_num_crtcs(dev));
		708	}
		709	if (!crtc->name) {
		710	drm_mode_object_put(dev, &crtc->base);
		711	return -ENOMEM;
		712	}
		713
3031	serge	714	crtc->base.properties = &crtc->properties;
		715
5060	serge	716	list_add_tail(&crtc->head, &config->crtc_list);
		717	config->num_crtc++;
3031	serge	718
5060	serge	719	crtc->primary = primary;
		720	crtc->cursor = cursor;
		721	if (primary)
		722	primary->possible_crtcs = 1 << drm_crtc_index(crtc);
		723	if (cursor)
		724	cursor->possible_crtcs = 1 << drm_crtc_index(crtc);
		725
6084	serge	726	if (drm_core_check_feature(dev, DRIVER_ATOMIC)) {
		727	drm_object_attach_property(&crtc->base, config->prop_active, 0);
		728	drm_object_attach_property(&crtc->base, config->prop_mode_id, 0);
		729	}
		730
5271	serge	731	return 0;
1123	serge	732	}
5060	serge	733	EXPORT_SYMBOL(drm_crtc_init_with_planes);
1123	serge	734
		735	/**
4075	Serge	736	* drm_crtc_cleanup - Clean up the core crtc usage
1123	serge	737	* @crtc: CRTC to cleanup
		738	*
4075	Serge	739	* This function cleans up @crtc and removes it from the DRM mode setting
		740	* core. Note that the function does not free the crtc structure itself,
		741	* this is the responsibility of the caller.
1123	serge	742	*/
		743	void drm_crtc_cleanup(struct drm_crtc *crtc)
		744	{
		745	struct drm_device *dev = crtc->dev;
		746
6084	serge	747	kfree(crtc->gamma_store);
		748	crtc->gamma_store = NULL;
1123	serge	749
5060	serge	750	drm_modeset_lock_fini(&crtc->mutex);
		751
1123	serge	752	drm_mode_object_put(dev, &crtc->base);
		753	list_del(&crtc->head);
		754	dev->mode_config.num_crtc--;
5271	serge	755
		756	WARN_ON(crtc->state && !crtc->funcs->atomic_destroy_state);
		757	if (crtc->state && crtc->funcs->atomic_destroy_state)
		758	crtc->funcs->atomic_destroy_state(crtc, crtc->state);
		759
6937	serge	760	kfree(crtc->name);
		761
5271	serge	762	memset(crtc, 0, sizeof(*crtc));
1123	serge	763	}
		764	EXPORT_SYMBOL(drm_crtc_cleanup);
		765
		766	/**
4560	Serge	767	* drm_crtc_index - find the index of a registered CRTC
		768	* @crtc: CRTC to find index for
		769	*
		770	* Given a registered CRTC, return the index of that CRTC within a DRM
		771	* device's list of CRTCs.
		772	*/
		773	unsigned int drm_crtc_index(struct drm_crtc *crtc)
		774	{
		775	unsigned int index = 0;
		776	struct drm_crtc *tmp;
		777
6084	serge	778	drm_for_each_crtc(tmp, crtc->dev) {
4560	Serge	779	if (tmp == crtc)
		780	return index;
		781
		782	index++;
		783	}
		784
		785	BUG();
		786	}
		787	EXPORT_SYMBOL(drm_crtc_index);
		788
4104	Serge	789	/*
1123	serge	790	* drm_mode_remove - remove and free a mode
		791	* @connector: connector list to modify
		792	* @mode: mode to remove
		793	*
		794	* Remove @mode from @connector's mode list, then free it.
		795	*/
4104	Serge	796	static void drm_mode_remove(struct drm_connector *connector,
6084	serge	797	struct drm_display_mode *mode)
1123	serge	798	{
		799	list_del(&mode->head);
3031	serge	800	drm_mode_destroy(connector->dev, mode);
1123	serge	801	}
		802
		803	/**
6084	serge	804	* drm_display_info_set_bus_formats - set the supported bus formats
		805	* @info: display info to store bus formats in
		806	* @formats: array containing the supported bus formats
		807	* @num_formats: the number of entries in the fmts array
		808	*
		809	* Store the supported bus formats in display info structure.
		810	* See MEDIA_BUS_FMT_* definitions in include/uapi/linux/media-bus-format.h for
		811	* a full list of available formats.
		812	*/
		813	int drm_display_info_set_bus_formats(struct drm_display_info *info,
		814	const u32 *formats,
		815	unsigned int num_formats)
		816	{
		817	u32 *fmts = NULL;
		818
		819	if (!formats && num_formats)
		820	return -EINVAL;
		821
		822	if (formats && num_formats) {
		823	fmts = kmemdup(formats, sizeof(formats) num_formats,
		824	GFP_KERNEL);
		825	if (!fmts)
		826	return -ENOMEM;
		827	}
		828
		829	kfree(info->bus_formats);
		830	info->bus_formats = fmts;
		831	info->num_bus_formats = num_formats;
		832
		833	return 0;
		834	}
		835	EXPORT_SYMBOL(drm_display_info_set_bus_formats);
		836
		837	/**
		838	* drm_connector_get_cmdline_mode - reads the user's cmdline mode
		839	* @connector: connector to quwery
		840	*
		841	* The kernel supports per-connector configration of its consoles through
		842	* use of the video= parameter. This function parses that option and
		843	* extracts the user's specified mode (or enable/disable status) for a
		844	* particular connector. This is typically only used during the early fbdev
		845	* setup.
		846	*/
		847	static void drm_connector_get_cmdline_mode(struct drm_connector *connector)
		848	{
		849	struct drm_cmdline_mode *mode = &connector->cmdline_mode;
		850	char *option = NULL;
		851
		852	if (fb_get_options(connector->name, &option))
		853	return;
		854
		855	if (!drm_mode_parse_command_line_for_connector(option,
		856	connector,
		857	mode))
		858	return;
		859
		860	if (mode->force) {
		861	const char *s;
		862
		863	switch (mode->force) {
		864	case DRM_FORCE_OFF:
		865	s = "OFF";
		866	break;
		867	case DRM_FORCE_ON_DIGITAL:
		868	s = "ON - dig";
		869	break;
		870	default:
		871	case DRM_FORCE_ON:
		872	s = "ON";
		873	break;
		874	}
		875
		876	DRM_INFO("forcing %s connector %s\n", connector->name, s);
		877	connector->force = mode->force;
		878	}
		879
		880	DRM_DEBUG_KMS("cmdline mode for connector %s %dx%d@%dHz%s%s%s\n",
		881	connector->name,
		882	mode->xres, mode->yres,
		883	mode->refresh_specified ? mode->refresh : 60,
		884	mode->rb ? " reduced blanking" : "",
		885	mode->margins ? " with margins" : "",
		886	mode->interlace ? " interlaced" : "");
		887	}
		888
		889	/**
1123	serge	890	* drm_connector_init - Init a preallocated connector
		891	* @dev: DRM device
		892	* @connector: the connector to init
		893	* @funcs: callbacks for this connector
3480	Serge	894	* @connector_type: user visible type of the connector
1123	serge	895	*
		896	* Initialises a preallocated connector. Connectors should be
		897	* subclassed as part of driver connector objects.
3031	serge	898	*
5060	serge	899	* Returns:
3031	serge	900	* Zero on success, error code on failure.
1123	serge	901	*/
3031	serge	902	int drm_connector_init(struct drm_device *dev,
6084	serge	903	struct drm_connector *connector,
		904	const struct drm_connector_funcs *funcs,
		905	int connector_type)
1123	serge	906	{
6084	serge	907	struct drm_mode_config *config = &dev->mode_config;
3031	serge	908	int ret;
4104	Serge	909	struct ida *connector_ida =
		910	&drm_connector_enum_list[connector_type].ida;
3031	serge	911
3480	Serge	912	drm_modeset_lock_all(dev);
1123	serge	913
5060	serge	914	ret = drm_mode_object_get_reg(dev, &connector->base, DRM_MODE_OBJECT_CONNECTOR, false);
3031	serge	915	if (ret)
5060	serge	916	goto out_unlock;
3031	serge	917
		918	connector->base.properties = &connector->properties;
1123	serge	919	connector->dev = dev;
		920	connector->funcs = funcs;
6937	serge	921
		922	connector->connector_id = ida_simple_get(&config->connector_ida, 0, 0, GFP_KERNEL);
		923	if (connector->connector_id < 0) {
		924	ret = connector->connector_id;
		925	goto out_put;
		926	}
		927
1123	serge	928	connector->connector_type = connector_type;
		929	connector->connector_type_id =
4104	Serge	930	ida_simple_get(connector_ida, 1, 0, GFP_KERNEL);
		931	if (connector->connector_type_id < 0) {
		932	ret = connector->connector_type_id;
6937	serge	933	goto out_put_id;
4104	Serge	934	}
5060	serge	935	connector->name =
		936	kasprintf(GFP_KERNEL, "%s-%d",
		937	drm_connector_enum_list[connector_type].name,
		938	connector->connector_type_id);
		939	if (!connector->name) {
		940	ret = -ENOMEM;
6937	serge	941	goto out_put_type_id;
5060	serge	942	}
		943
1123	serge	944	INIT_LIST_HEAD(&connector->probed_modes);
		945	INIT_LIST_HEAD(&connector->modes);
		946	connector->edid_blob_ptr = NULL;
3192	Serge	947	connector->status = connector_status_unknown;
1123	serge	948
6084	serge	949	drm_connector_get_cmdline_mode(connector);
1123	serge	950
6084	serge	951	/* We should add connectors at the end to avoid upsetting the connector
		952	* index too much. */
		953	list_add_tail(&connector->head, &config->connector_list);
		954	config->num_connector++;
		955
3031	serge	956	if (connector_type != DRM_MODE_CONNECTOR_VIRTUAL)
3192	Serge	957	drm_object_attach_property(&connector->base,
6084	serge	958	config->edid_property,
3031	serge	959	0);
1123	serge	960
3192	Serge	961	drm_object_attach_property(&connector->base,
6084	serge	962	config->dpms_property, 0);
1123	serge	963
6084	serge	964	if (drm_core_check_feature(dev, DRIVER_ATOMIC)) {
		965	drm_object_attach_property(&connector->base, config->prop_crtc_id, 0);
		966	}
		967
5060	serge	968	connector->debugfs_entry = NULL;
6937	serge	969	out_put_type_id:
		970	if (ret)
		971	ida_remove(connector_ida, connector->connector_type_id);
		972	out_put_id:
		973	if (ret)
		974	ida_remove(&config->connector_ida, connector->connector_id);
5060	serge	975	out_put:
		976	if (ret)
		977	drm_mode_object_put(dev, &connector->base);
		978
		979	out_unlock:
3480	Serge	980	drm_modeset_unlock_all(dev);
3031	serge	981
		982	return ret;
1123	serge	983	}
		984	EXPORT_SYMBOL(drm_connector_init);
		985
		986	/**
		987	* drm_connector_cleanup - cleans up an initialised connector
		988	* @connector: connector to cleanup
		989	*
		990	* Cleans up the connector but doesn't free the object.
		991	*/
		992	void drm_connector_cleanup(struct drm_connector *connector)
		993	{
		994	struct drm_device *dev = connector->dev;
		995	struct drm_display_mode mode, t;
		996
6084	serge	997	if (connector->tile_group) {
		998	drm_mode_put_tile_group(dev, connector->tile_group);
		999	connector->tile_group = NULL;
		1000	}
		1001
1123	serge	1002	list_for_each_entry_safe(mode, t, &connector->probed_modes, head)
		1003	drm_mode_remove(connector, mode);
		1004
		1005	list_for_each_entry_safe(mode, t, &connector->modes, head)
		1006	drm_mode_remove(connector, mode);
		1007
4104	Serge	1008	ida_remove(&drm_connector_enum_list[connector->connector_type].ida,
		1009	connector->connector_type_id);
		1010
6937	serge	1011	ida_remove(&dev->mode_config.connector_ida,
		1012	connector->connector_id);
		1013
6084	serge	1014	kfree(connector->display_info.bus_formats);
1123	serge	1015	drm_mode_object_put(dev, &connector->base);
5060	serge	1016	kfree(connector->name);
		1017	connector->name = NULL;
1123	serge	1018	list_del(&connector->head);
2160	serge	1019	dev->mode_config.num_connector--;
5271	serge	1020
		1021	WARN_ON(connector->state && !connector->funcs->atomic_destroy_state);
		1022	if (connector->state && connector->funcs->atomic_destroy_state)
		1023	connector->funcs->atomic_destroy_state(connector,
		1024	connector->state);
		1025
		1026	memset(connector, 0, sizeof(*connector));
1123	serge	1027	}
		1028	EXPORT_SYMBOL(drm_connector_cleanup);
		1029
5060	serge	1030	/**
		1031	* drm_connector_register - register a connector
		1032	* @connector: the connector to register
		1033	*
		1034	* Register userspace interfaces for a connector
		1035	*
		1036	* Returns:
		1037	* Zero on success, error code on failure.
		1038	*/
		1039	int drm_connector_register(struct drm_connector *connector)
		1040	{
		1041	int ret;
		1042
		1043	drm_mode_object_register(connector->dev, &connector->base);
		1044
6084	serge	1045	ret = drm_sysfs_connector_add(connector);
		1046	if (ret)
		1047	return ret;
6296	serge	1048
		1049	ret = drm_debugfs_connector_add(connector);
		1050	if (ret) {
		1051	drm_sysfs_connector_remove(connector);
		1052	return ret;
		1053	}
		1054
5060	serge	1055	return 0;
		1056	}
		1057	EXPORT_SYMBOL(drm_connector_register);
		1058
		1059	/**
		1060	* drm_connector_unregister - unregister a connector
		1061	* @connector: the connector to unregister
		1062	*
		1063	* Unregister userspace interfaces for a connector
		1064	*/
		1065	void drm_connector_unregister(struct drm_connector *connector)
		1066	{
6084	serge	1067	drm_sysfs_connector_remove(connector);
6296	serge	1068	drm_debugfs_connector_remove(connector);
5060	serge	1069	}
		1070	EXPORT_SYMBOL(drm_connector_unregister);
		1071
		1072
		1073	/**
		1074	* drm_connector_unplug_all - unregister connector userspace interfaces
		1075	* @dev: drm device
		1076	*
		1077	* This function unregisters all connector userspace interfaces in sysfs. Should
		1078	* be call when the device is disconnected, e.g. from an usb driver's
		1079	* ->disconnect callback.
		1080	*/
3031	serge	1081	void drm_connector_unplug_all(struct drm_device *dev)
		1082	{
		1083	struct drm_connector *connector;
		1084
6084	serge	1085	/* FIXME: taking the mode config mutex ends up in a clash with sysfs */
5060	serge	1086	list_for_each_entry(connector, &dev->mode_config.connector_list, head)
		1087	drm_connector_unregister(connector);
3031	serge	1088
		1089	}
		1090	EXPORT_SYMBOL(drm_connector_unplug_all);
		1091
5060	serge	1092	/**
		1093	* drm_encoder_init - Init a preallocated encoder
		1094	* @dev: drm device
		1095	* @encoder: the encoder to init
		1096	* @funcs: callbacks for this encoder
		1097	* @encoder_type: user visible type of the encoder
6937	serge	1098	* @name: printf style format string for the encoder name, or NULL for default name
5060	serge	1099	*
		1100	* Initialises a preallocated encoder. Encoder should be
		1101	* subclassed as part of driver encoder objects.
		1102	*
		1103	* Returns:
		1104	* Zero on success, error code on failure.
		1105	*/
3031	serge	1106	int drm_encoder_init(struct drm_device *dev,
1123	serge	1107	struct drm_encoder *encoder,
		1108	const struct drm_encoder_funcs *funcs,
6937	serge	1109	int encoder_type, const char *name, ...)
1123	serge	1110	{
3031	serge	1111	int ret;
		1112
3480	Serge	1113	drm_modeset_lock_all(dev);
1123	serge	1114
3031	serge	1115	ret = drm_mode_object_get(dev, &encoder->base, DRM_MODE_OBJECT_ENCODER);
		1116	if (ret)
5060	serge	1117	goto out_unlock;
3031	serge	1118
1123	serge	1119	encoder->dev = dev;
		1120	encoder->encoder_type = encoder_type;
		1121	encoder->funcs = funcs;
6937	serge	1122	if (name) {
		1123	va_list ap;
		1124
		1125	va_start(ap, name);
		1126	encoder->name = kvasprintf(GFP_KERNEL, name, ap);
		1127	va_end(ap);
		1128	} else {
5060	serge	1129	encoder->name = kasprintf(GFP_KERNEL, "%s-%d",
		1130	drm_encoder_enum_list[encoder_type].name,
		1131	encoder->base.id);
6937	serge	1132	}
5060	serge	1133	if (!encoder->name) {
		1134	ret = -ENOMEM;
		1135	goto out_put;
		1136	}
1123	serge	1137
		1138	list_add_tail(&encoder->head, &dev->mode_config.encoder_list);
		1139	dev->mode_config.num_encoder++;
		1140
5060	serge	1141	out_put:
		1142	if (ret)
		1143	drm_mode_object_put(dev, &encoder->base);
		1144
		1145	out_unlock:
3480	Serge	1146	drm_modeset_unlock_all(dev);
3031	serge	1147
		1148	return ret;
1123	serge	1149	}
		1150	EXPORT_SYMBOL(drm_encoder_init);
		1151
5060	serge	1152	/**
		1153	* drm_encoder_cleanup - cleans up an initialised encoder
		1154	* @encoder: encoder to cleanup
		1155	*
		1156	* Cleans up the encoder but doesn't free the object.
		1157	*/
1123	serge	1158	void drm_encoder_cleanup(struct drm_encoder *encoder)
		1159	{
		1160	struct drm_device *dev = encoder->dev;
6084	serge	1161
3480	Serge	1162	drm_modeset_lock_all(dev);
1123	serge	1163	drm_mode_object_put(dev, &encoder->base);
5060	serge	1164	kfree(encoder->name);
1123	serge	1165	list_del(&encoder->head);
2160	serge	1166	dev->mode_config.num_encoder--;
3480	Serge	1167	drm_modeset_unlock_all(dev);
5271	serge	1168
		1169	memset(encoder, 0, sizeof(*encoder));
1123	serge	1170	}
		1171	EXPORT_SYMBOL(drm_encoder_cleanup);
		1172
6937	serge	1173	static unsigned int drm_num_planes(struct drm_device *dev)
		1174	{
		1175	unsigned int num = 0;
		1176	struct drm_plane *tmp;
		1177
		1178	drm_for_each_plane(tmp, dev) {
		1179	num++;
		1180	}
		1181
		1182	return num;
		1183	}
		1184
4075	Serge	1185	/**
5060	serge	1186	* drm_universal_plane_init - Initialize a new universal plane object
4075	Serge	1187	* @dev: DRM device
		1188	* @plane: plane object to init
		1189	* @possible_crtcs: bitmask of possible CRTCs
		1190	* @funcs: callbacks for the new plane
		1191	* @formats: array of supported formats (%DRM_FORMAT_*)
		1192	* @format_count: number of elements in @formats
5060	serge	1193	* @type: type of plane (overlay, primary, cursor)
6937	serge	1194	* @name: printf style format string for the plane name, or NULL for default name
4075	Serge	1195	*
5060	serge	1196	* Initializes a plane object of type @type.
4075	Serge	1197	*
5060	serge	1198	* Returns:
4075	Serge	1199	* Zero on success, error code on failure.
		1200	*/
5060	serge	1201	int drm_universal_plane_init(struct drm_device dev, struct drm_plane plane,
6084	serge	1202	unsigned long possible_crtcs,
		1203	const struct drm_plane_funcs *funcs,
		1204	const uint32_t *formats, unsigned int format_count,
6937	serge	1205	enum drm_plane_type type,
		1206	const char *name, ...)
3031	serge	1207	{
6084	serge	1208	struct drm_mode_config *config = &dev->mode_config;
3031	serge	1209	int ret;
		1210
		1211	ret = drm_mode_object_get(dev, &plane->base, DRM_MODE_OBJECT_PLANE);
		1212	if (ret)
5271	serge	1213	return ret;
3031	serge	1214
5271	serge	1215	drm_modeset_lock_init(&plane->mutex);
		1216
3031	serge	1217	plane->base.properties = &plane->properties;
		1218	plane->dev = dev;
		1219	plane->funcs = funcs;
6084	serge	1220	plane->format_types = kmalloc_array(format_count, sizeof(uint32_t),
		1221	GFP_KERNEL);
3031	serge	1222	if (!plane->format_types) {
		1223	DRM_DEBUG_KMS("out of memory when allocating plane\n");
		1224	drm_mode_object_put(dev, &plane->base);
5271	serge	1225	return -ENOMEM;
3031	serge	1226	}
		1227
6937	serge	1228	if (name) {
		1229	va_list ap;
		1230
		1231	va_start(ap, name);
		1232	plane->name = kvasprintf(GFP_KERNEL, name, ap);
		1233	va_end(ap);
		1234	} else {
		1235	plane->name = kasprintf(GFP_KERNEL, "plane-%d",
		1236	drm_num_planes(dev));
		1237	}
		1238	if (!plane->name) {
		1239	kfree(plane->format_types);
		1240	drm_mode_object_put(dev, &plane->base);
		1241	return -ENOMEM;
		1242	}
		1243
3031	serge	1244	memcpy(plane->format_types, formats, format_count * sizeof(uint32_t));
		1245	plane->format_count = format_count;
		1246	plane->possible_crtcs = possible_crtcs;
5060	serge	1247	plane->type = type;
3031	serge	1248
6084	serge	1249	list_add_tail(&plane->head, &config->plane_list);
		1250	config->num_total_plane++;
5060	serge	1251	if (plane->type == DRM_PLANE_TYPE_OVERLAY)
6084	serge	1252	config->num_overlay_plane++;
3031	serge	1253
5060	serge	1254	drm_object_attach_property(&plane->base,
6084	serge	1255	config->plane_type_property,
5060	serge	1256	plane->type);
		1257
6084	serge	1258	if (drm_core_check_feature(dev, DRIVER_ATOMIC)) {
		1259	drm_object_attach_property(&plane->base, config->prop_fb_id, 0);
		1260	drm_object_attach_property(&plane->base, config->prop_crtc_id, 0);
		1261	drm_object_attach_property(&plane->base, config->prop_crtc_x, 0);
		1262	drm_object_attach_property(&plane->base, config->prop_crtc_y, 0);
		1263	drm_object_attach_property(&plane->base, config->prop_crtc_w, 0);
		1264	drm_object_attach_property(&plane->base, config->prop_crtc_h, 0);
		1265	drm_object_attach_property(&plane->base, config->prop_src_x, 0);
		1266	drm_object_attach_property(&plane->base, config->prop_src_y, 0);
		1267	drm_object_attach_property(&plane->base, config->prop_src_w, 0);
		1268	drm_object_attach_property(&plane->base, config->prop_src_h, 0);
		1269	}
		1270
5271	serge	1271	return 0;
3031	serge	1272	}
5060	serge	1273	EXPORT_SYMBOL(drm_universal_plane_init);
		1274
		1275	/**
		1276	* drm_plane_init - Initialize a legacy plane
		1277	* @dev: DRM device
		1278	* @plane: plane object to init
		1279	* @possible_crtcs: bitmask of possible CRTCs
		1280	* @funcs: callbacks for the new plane
		1281	* @formats: array of supported formats (%DRM_FORMAT_*)
		1282	* @format_count: number of elements in @formats
		1283	* @is_primary: plane type (primary vs overlay)
		1284	*
		1285	* Legacy API to initialize a DRM plane.
		1286	*
		1287	* New drivers should call drm_universal_plane_init() instead.
		1288	*
		1289	* Returns:
		1290	* Zero on success, error code on failure.
		1291	*/
		1292	int drm_plane_init(struct drm_device dev, struct drm_plane plane,
		1293	unsigned long possible_crtcs,
		1294	const struct drm_plane_funcs *funcs,
6084	serge	1295	const uint32_t *formats, unsigned int format_count,
5060	serge	1296	bool is_primary)
		1297	{
		1298	enum drm_plane_type type;
		1299
		1300	type = is_primary ? DRM_PLANE_TYPE_PRIMARY : DRM_PLANE_TYPE_OVERLAY;
		1301	return drm_universal_plane_init(dev, plane, possible_crtcs, funcs,
6937	serge	1302	formats, format_count, type, NULL);
5060	serge	1303	}
3031	serge	1304	EXPORT_SYMBOL(drm_plane_init);
		1305
4075	Serge	1306	/**
		1307	* drm_plane_cleanup - Clean up the core plane usage
		1308	* @plane: plane to cleanup
		1309	*
		1310	* This function cleans up @plane and removes it from the DRM mode setting
		1311	* core. Note that the function does not free the plane structure itself,
		1312	* this is the responsibility of the caller.
		1313	*/
3031	serge	1314	void drm_plane_cleanup(struct drm_plane *plane)
		1315	{
		1316	struct drm_device *dev = plane->dev;
		1317
3480	Serge	1318	drm_modeset_lock_all(dev);
3031	serge	1319	kfree(plane->format_types);
		1320	drm_mode_object_put(dev, &plane->base);
5060	serge	1321
		1322	BUG_ON(list_empty(&plane->head));
		1323
6084	serge	1324	list_del(&plane->head);
5060	serge	1325	dev->mode_config.num_total_plane--;
		1326	if (plane->type == DRM_PLANE_TYPE_OVERLAY)
		1327	dev->mode_config.num_overlay_plane--;
3480	Serge	1328	drm_modeset_unlock_all(dev);
5271	serge	1329
		1330	WARN_ON(plane->state && !plane->funcs->atomic_destroy_state);
		1331	if (plane->state && plane->funcs->atomic_destroy_state)
		1332	plane->funcs->atomic_destroy_state(plane, plane->state);
		1333
6937	serge	1334	kfree(plane->name);
		1335
5271	serge	1336	memset(plane, 0, sizeof(*plane));
3031	serge	1337	}
		1338	EXPORT_SYMBOL(drm_plane_cleanup);
		1339
1123	serge	1340	/**
5271	serge	1341	* drm_plane_index - find the index of a registered plane
		1342	* @plane: plane to find index for
		1343	*
		1344	* Given a registered plane, return the index of that CRTC within a DRM
		1345	* device's list of planes.
		1346	*/
		1347	unsigned int drm_plane_index(struct drm_plane *plane)
		1348	{
		1349	unsigned int index = 0;
		1350	struct drm_plane *tmp;
		1351
6084	serge	1352	drm_for_each_plane(tmp, plane->dev) {
5271	serge	1353	if (tmp == plane)
		1354	return index;
		1355
		1356	index++;
		1357	}
		1358
		1359	BUG();
		1360	}
		1361	EXPORT_SYMBOL(drm_plane_index);
		1362
		1363	/**
6084	serge	1364	* drm_plane_from_index - find the registered plane at an index
		1365	* @dev: DRM device
		1366	* @idx: index of registered plane to find for
		1367	*
		1368	* Given a plane index, return the registered plane from DRM device's
		1369	* list of planes with matching index.
		1370	*/
		1371	struct drm_plane *
		1372	drm_plane_from_index(struct drm_device *dev, int idx)
		1373	{
		1374	struct drm_plane *plane;
		1375	unsigned int i = 0;
		1376
		1377	drm_for_each_plane(plane, dev) {
		1378	if (i == idx)
		1379	return plane;
		1380	i++;
		1381	}
		1382	return NULL;
		1383	}
		1384	EXPORT_SYMBOL(drm_plane_from_index);
		1385
		1386	/**
4075	Serge	1387	* drm_plane_force_disable - Forcibly disable a plane
		1388	* @plane: plane to disable
		1389	*
		1390	* Forces the plane to be disabled.
		1391	*
		1392	* Used when the plane's current framebuffer is destroyed,
		1393	* and when restoring fbdev mode.
		1394	*/
		1395	void drm_plane_force_disable(struct drm_plane *plane)
		1396	{
		1397	int ret;
		1398
5271	serge	1399	if (!plane->fb)
4075	Serge	1400	return;
		1401
5271	serge	1402	plane->old_fb = plane->fb;
4075	Serge	1403	ret = plane->funcs->disable_plane(plane);
5060	serge	1404	if (ret) {
4075	Serge	1405	DRM_ERROR("failed to disable plane with busy fb\n");
5271	serge	1406	plane->old_fb = NULL;
5060	serge	1407	return;
		1408	}
4075	Serge	1409	/* disconnect the plane from the fb and crtc: */
6084	serge	1410	drm_framebuffer_unreference(plane->old_fb);
5271	serge	1411	plane->old_fb = NULL;
4075	Serge	1412	plane->fb = NULL;
		1413	plane->crtc = NULL;
		1414	}
		1415	EXPORT_SYMBOL(drm_plane_force_disable);
		1416
6084	serge	1417	static int drm_mode_create_standard_properties(struct drm_device *dev)
1123	serge	1418	{
6084	serge	1419	struct drm_property *prop;
1123	serge	1420
		1421	/*
		1422	* Standard properties (apply to all connectors)
		1423	*/
6084	serge	1424	prop = drm_property_create(dev, DRM_MODE_PROP_BLOB \|
1123	serge	1425	DRM_MODE_PROP_IMMUTABLE,
		1426	"EDID", 0);
6084	serge	1427	if (!prop)
		1428	return -ENOMEM;
		1429	dev->mode_config.edid_property = prop;
1123	serge	1430
6084	serge	1431	prop = drm_property_create_enum(dev, 0,
3031	serge	1432	"DPMS", drm_dpms_enum_list,
		1433	ARRAY_SIZE(drm_dpms_enum_list));
6084	serge	1434	if (!prop)
		1435	return -ENOMEM;
		1436	dev->mode_config.dpms_property = prop;
1123	serge	1437
6084	serge	1438	prop = drm_property_create(dev,
		1439	DRM_MODE_PROP_BLOB \|
		1440	DRM_MODE_PROP_IMMUTABLE,
		1441	"PATH", 0);
		1442	if (!prop)
		1443	return -ENOMEM;
		1444	dev->mode_config.path_property = prop;
5060	serge	1445
6084	serge	1446	prop = drm_property_create(dev,
		1447	DRM_MODE_PROP_BLOB \|
		1448	DRM_MODE_PROP_IMMUTABLE,
		1449	"TILE", 0);
		1450	if (!prop)
		1451	return -ENOMEM;
		1452	dev->mode_config.tile_property = prop;
5271	serge	1453
6084	serge	1454	prop = drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE,
5060	serge	1455	"type", drm_plane_type_enum_list,
		1456	ARRAY_SIZE(drm_plane_type_enum_list));
6084	serge	1457	if (!prop)
		1458	return -ENOMEM;
		1459	dev->mode_config.plane_type_property = prop;
5060	serge	1460
6084	serge	1461	prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
		1462	"SRC_X", 0, UINT_MAX);
		1463	if (!prop)
		1464	return -ENOMEM;
		1465	dev->mode_config.prop_src_x = prop;
		1466
		1467	prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
		1468	"SRC_Y", 0, UINT_MAX);
		1469	if (!prop)
		1470	return -ENOMEM;
		1471	dev->mode_config.prop_src_y = prop;
		1472
		1473	prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
		1474	"SRC_W", 0, UINT_MAX);
		1475	if (!prop)
		1476	return -ENOMEM;
		1477	dev->mode_config.prop_src_w = prop;
		1478
		1479	prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
		1480	"SRC_H", 0, UINT_MAX);
		1481	if (!prop)
		1482	return -ENOMEM;
		1483	dev->mode_config.prop_src_h = prop;
		1484
		1485	prop = drm_property_create_signed_range(dev, DRM_MODE_PROP_ATOMIC,
		1486	"CRTC_X", INT_MIN, INT_MAX);
		1487	if (!prop)
		1488	return -ENOMEM;
		1489	dev->mode_config.prop_crtc_x = prop;
		1490
		1491	prop = drm_property_create_signed_range(dev, DRM_MODE_PROP_ATOMIC,
		1492	"CRTC_Y", INT_MIN, INT_MAX);
		1493	if (!prop)
		1494	return -ENOMEM;
		1495	dev->mode_config.prop_crtc_y = prop;
		1496
		1497	prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
		1498	"CRTC_W", 0, INT_MAX);
		1499	if (!prop)
		1500	return -ENOMEM;
		1501	dev->mode_config.prop_crtc_w = prop;
		1502
		1503	prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
		1504	"CRTC_H", 0, INT_MAX);
		1505	if (!prop)
		1506	return -ENOMEM;
		1507	dev->mode_config.prop_crtc_h = prop;
		1508
		1509	prop = drm_property_create_object(dev, DRM_MODE_PROP_ATOMIC,
		1510	"FB_ID", DRM_MODE_OBJECT_FB);
		1511	if (!prop)
		1512	return -ENOMEM;
		1513	dev->mode_config.prop_fb_id = prop;
		1514
		1515	prop = drm_property_create_object(dev, DRM_MODE_PROP_ATOMIC,
		1516	"CRTC_ID", DRM_MODE_OBJECT_CRTC);
		1517	if (!prop)
		1518	return -ENOMEM;
		1519	dev->mode_config.prop_crtc_id = prop;
		1520
		1521	prop = drm_property_create_bool(dev, DRM_MODE_PROP_ATOMIC,
		1522	"ACTIVE");
		1523	if (!prop)
		1524	return -ENOMEM;
		1525	dev->mode_config.prop_active = prop;
		1526
		1527	prop = drm_property_create(dev,
		1528	DRM_MODE_PROP_ATOMIC \| DRM_MODE_PROP_BLOB,
		1529	"MODE_ID", 0);
		1530	if (!prop)
		1531	return -ENOMEM;
		1532	dev->mode_config.prop_mode_id = prop;
		1533
5060	serge	1534	return 0;
		1535	}
		1536
1123	serge	1537	/**
		1538	* drm_mode_create_dvi_i_properties - create DVI-I specific connector properties
		1539	* @dev: DRM device
		1540	*
		1541	* Called by a driver the first time a DVI-I connector is made.
		1542	*/
		1543	int drm_mode_create_dvi_i_properties(struct drm_device *dev)
		1544	{
		1545	struct drm_property *dvi_i_selector;
		1546	struct drm_property *dvi_i_subconnector;
		1547
		1548	if (dev->mode_config.dvi_i_select_subconnector_property)
		1549	return 0;
		1550
		1551	dvi_i_selector =
3031	serge	1552	drm_property_create_enum(dev, 0,
1123	serge	1553	"select subconnector",
3031	serge	1554	drm_dvi_i_select_enum_list,
1123	serge	1555	ARRAY_SIZE(drm_dvi_i_select_enum_list));
		1556	dev->mode_config.dvi_i_select_subconnector_property = dvi_i_selector;
		1557
3031	serge	1558	dvi_i_subconnector = drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE,
1123	serge	1559	"subconnector",
3031	serge	1560	drm_dvi_i_subconnector_enum_list,
1123	serge	1561	ARRAY_SIZE(drm_dvi_i_subconnector_enum_list));
		1562	dev->mode_config.dvi_i_subconnector_property = dvi_i_subconnector;
		1563
		1564	return 0;
		1565	}
		1566	EXPORT_SYMBOL(drm_mode_create_dvi_i_properties);
		1567
		1568	/**
		1569	* drm_create_tv_properties - create TV specific connector properties
		1570	* @dev: DRM device
		1571	* @num_modes: number of different TV formats (modes) supported
		1572	* @modes: array of pointers to strings containing name of each format
		1573	*
		1574	* Called by a driver's TV initialization routine, this function creates
		1575	* the TV specific connector properties for a given device. Caller is
		1576	* responsible for allocating a list of format names and passing them to
		1577	* this routine.
		1578	*/
5271	serge	1579	int drm_mode_create_tv_properties(struct drm_device *dev,
		1580	unsigned int num_modes,
6084	serge	1581	const char * const modes[])
1123	serge	1582	{
		1583	struct drm_property *tv_selector;
		1584	struct drm_property *tv_subconnector;
5271	serge	1585	unsigned int i;
1123	serge	1586
		1587	if (dev->mode_config.tv_select_subconnector_property)
		1588	return 0;
		1589
		1590	/*
		1591	* Basic connector properties
		1592	*/
3031	serge	1593	tv_selector = drm_property_create_enum(dev, 0,
1123	serge	1594	"select subconnector",
3031	serge	1595	drm_tv_select_enum_list,
1123	serge	1596	ARRAY_SIZE(drm_tv_select_enum_list));
6084	serge	1597	if (!tv_selector)
		1598	goto nomem;
		1599
1123	serge	1600	dev->mode_config.tv_select_subconnector_property = tv_selector;
		1601
		1602	tv_subconnector =
3031	serge	1603	drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE,
		1604	"subconnector",
		1605	drm_tv_subconnector_enum_list,
1123	serge	1606	ARRAY_SIZE(drm_tv_subconnector_enum_list));
6084	serge	1607	if (!tv_subconnector)
		1608	goto nomem;
1123	serge	1609	dev->mode_config.tv_subconnector_property = tv_subconnector;
		1610
		1611	/*
		1612	* Other, TV specific properties: margins & TV modes.
		1613	*/
		1614	dev->mode_config.tv_left_margin_property =
3031	serge	1615	drm_property_create_range(dev, 0, "left margin", 0, 100);
6084	serge	1616	if (!dev->mode_config.tv_left_margin_property)
		1617	goto nomem;
1123	serge	1618
		1619	dev->mode_config.tv_right_margin_property =
3031	serge	1620	drm_property_create_range(dev, 0, "right margin", 0, 100);
6084	serge	1621	if (!dev->mode_config.tv_right_margin_property)
		1622	goto nomem;
1123	serge	1623
		1624	dev->mode_config.tv_top_margin_property =
3031	serge	1625	drm_property_create_range(dev, 0, "top margin", 0, 100);
6084	serge	1626	if (!dev->mode_config.tv_top_margin_property)
		1627	goto nomem;
1123	serge	1628
		1629	dev->mode_config.tv_bottom_margin_property =
3031	serge	1630	drm_property_create_range(dev, 0, "bottom margin", 0, 100);
6084	serge	1631	if (!dev->mode_config.tv_bottom_margin_property)
		1632	goto nomem;
1123	serge	1633
		1634	dev->mode_config.tv_mode_property =
		1635	drm_property_create(dev, DRM_MODE_PROP_ENUM,
		1636	"mode", num_modes);
6084	serge	1637	if (!dev->mode_config.tv_mode_property)
		1638	goto nomem;
		1639
1123	serge	1640	for (i = 0; i < num_modes; i++)
		1641	drm_property_add_enum(dev->mode_config.tv_mode_property, i,
		1642	i, modes[i]);
		1643
1179	serge	1644	dev->mode_config.tv_brightness_property =
3031	serge	1645	drm_property_create_range(dev, 0, "brightness", 0, 100);
6084	serge	1646	if (!dev->mode_config.tv_brightness_property)
		1647	goto nomem;
1179	serge	1648
		1649	dev->mode_config.tv_contrast_property =
3031	serge	1650	drm_property_create_range(dev, 0, "contrast", 0, 100);
6084	serge	1651	if (!dev->mode_config.tv_contrast_property)
		1652	goto nomem;
1179	serge	1653
		1654	dev->mode_config.tv_flicker_reduction_property =
3031	serge	1655	drm_property_create_range(dev, 0, "flicker reduction", 0, 100);
6084	serge	1656	if (!dev->mode_config.tv_flicker_reduction_property)
		1657	goto nomem;
1179	serge	1658
		1659	dev->mode_config.tv_overscan_property =
3031	serge	1660	drm_property_create_range(dev, 0, "overscan", 0, 100);
6084	serge	1661	if (!dev->mode_config.tv_overscan_property)
		1662	goto nomem;
1179	serge	1663
		1664	dev->mode_config.tv_saturation_property =
3031	serge	1665	drm_property_create_range(dev, 0, "saturation", 0, 100);
6084	serge	1666	if (!dev->mode_config.tv_saturation_property)
		1667	goto nomem;
1179	serge	1668
		1669	dev->mode_config.tv_hue_property =
3031	serge	1670	drm_property_create_range(dev, 0, "hue", 0, 100);
6084	serge	1671	if (!dev->mode_config.tv_hue_property)
		1672	goto nomem;
1179	serge	1673
1123	serge	1674	return 0;
6084	serge	1675	nomem:
		1676	return -ENOMEM;
1123	serge	1677	}
		1678	EXPORT_SYMBOL(drm_mode_create_tv_properties);
		1679
		1680	/**
		1681	* drm_mode_create_scaling_mode_property - create scaling mode property
		1682	* @dev: DRM device
		1683	*
		1684	* Called by a driver the first time it's needed, must be attached to desired
		1685	* connectors.
		1686	*/
		1687	int drm_mode_create_scaling_mode_property(struct drm_device *dev)
		1688	{
		1689	struct drm_property *scaling_mode;
		1690
		1691	if (dev->mode_config.scaling_mode_property)
		1692	return 0;
		1693
		1694	scaling_mode =
3031	serge	1695	drm_property_create_enum(dev, 0, "scaling mode",
		1696	drm_scaling_mode_enum_list,
1123	serge	1697	ARRAY_SIZE(drm_scaling_mode_enum_list));
		1698
		1699	dev->mode_config.scaling_mode_property = scaling_mode;
		1700
		1701	return 0;
		1702	}
		1703	EXPORT_SYMBOL(drm_mode_create_scaling_mode_property);
		1704
		1705	/**
5060	serge	1706	* drm_mode_create_aspect_ratio_property - create aspect ratio property
		1707	* @dev: DRM device
		1708	*
		1709	* Called by a driver the first time it's needed, must be attached to desired
		1710	* connectors.
		1711	*
		1712	* Returns:
5271	serge	1713	* Zero on success, negative errno on failure.
5060	serge	1714	*/
		1715	int drm_mode_create_aspect_ratio_property(struct drm_device *dev)
		1716	{
		1717	if (dev->mode_config.aspect_ratio_property)
		1718	return 0;
		1719
		1720	dev->mode_config.aspect_ratio_property =
		1721	drm_property_create_enum(dev, 0, "aspect ratio",
		1722	drm_aspect_ratio_enum_list,
		1723	ARRAY_SIZE(drm_aspect_ratio_enum_list));
		1724
		1725	if (dev->mode_config.aspect_ratio_property == NULL)
		1726	return -ENOMEM;
		1727
		1728	return 0;
		1729	}
		1730	EXPORT_SYMBOL(drm_mode_create_aspect_ratio_property);
		1731
		1732	/**
1321	serge	1733	* drm_mode_create_dirty_property - create dirty property
		1734	* @dev: DRM device
		1735	*
		1736	* Called by a driver the first time it's needed, must be attached to desired
		1737	* connectors.
		1738	*/
		1739	int drm_mode_create_dirty_info_property(struct drm_device *dev)
		1740	{
		1741	struct drm_property *dirty_info;
		1742
		1743	if (dev->mode_config.dirty_info_property)
		1744	return 0;
		1745
		1746	dirty_info =
3031	serge	1747	drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE,
1321	serge	1748	"dirty",
3031	serge	1749	drm_dirty_info_enum_list,
1321	serge	1750	ARRAY_SIZE(drm_dirty_info_enum_list));
		1751	dev->mode_config.dirty_info_property = dirty_info;
		1752
		1753	return 0;
		1754	}
		1755	EXPORT_SYMBOL(drm_mode_create_dirty_info_property);
		1756
5271	serge	1757	/**
		1758	* drm_mode_create_suggested_offset_properties - create suggests offset properties
		1759	* @dev: DRM device
		1760	*
		1761	* Create the the suggested x/y offset property for connectors.
		1762	*/
		1763	int drm_mode_create_suggested_offset_properties(struct drm_device *dev)
		1764	{
		1765	if (dev->mode_config.suggested_x_property && dev->mode_config.suggested_y_property)
		1766	return 0;
		1767
		1768	dev->mode_config.suggested_x_property =
		1769	drm_property_create_range(dev, DRM_MODE_PROP_IMMUTABLE, "suggested X", 0, 0xffffffff);
		1770
		1771	dev->mode_config.suggested_y_property =
		1772	drm_property_create_range(dev, DRM_MODE_PROP_IMMUTABLE, "suggested Y", 0, 0xffffffff);
		1773
		1774	if (dev->mode_config.suggested_x_property == NULL \|\|
		1775	dev->mode_config.suggested_y_property == NULL)
		1776	return -ENOMEM;
		1777	return 0;
		1778	}
		1779	EXPORT_SYMBOL(drm_mode_create_suggested_offset_properties);
		1780
1123	serge	1781	#if 0
		1782	/**
		1783	* drm_mode_getresources - get graphics configuration
3480	Serge	1784	* @dev: drm device for the ioctl
		1785	* @data: data pointer for the ioctl
		1786	* @file_priv: drm file for the ioctl call
1123	serge	1787	*
		1788	* Construct a set of configuration description structures and return
		1789	* them to the user, including CRTC, connector and framebuffer configuration.
		1790	*
		1791	* Called by the user via ioctl.
		1792	*
5060	serge	1793	* Returns:
5271	serge	1794	* Zero on success, negative errno on failure.
1123	serge	1795	*/
		1796	int drm_mode_getresources(struct drm_device dev, void data,
		1797	struct drm_file *file_priv)
		1798	{
		1799	struct drm_mode_card_res *card_res = data;
		1800	struct list_head *lh;
		1801	struct drm_framebuffer *fb;
		1802	struct drm_connector *connector;
		1803	struct drm_crtc *crtc;
		1804	struct drm_encoder *encoder;
		1805	int ret = 0;
		1806	int connector_count = 0;
		1807	int crtc_count = 0;
		1808	int fb_count = 0;
		1809	int encoder_count = 0;
6084	serge	1810	int copied = 0;
1123	serge	1811	uint32_t __user *fb_id;
		1812	uint32_t __user *crtc_id;
		1813	uint32_t __user *connector_id;
		1814	uint32_t __user *encoder_id;
		1815
1963	serge	1816	if (!drm_core_check_feature(dev, DRIVER_MODESET))
		1817	return -EINVAL;
		1818
1123	serge	1819
3480	Serge	1820	mutex_lock(&file_priv->fbs_lock);
1123	serge	1821	/*
		1822	* For the non-control nodes we need to limit the list of resources
		1823	* by IDs in the group list for this node
		1824	*/
		1825	list_for_each(lh, &file_priv->fbs)
		1826	fb_count++;
		1827
3480	Serge	1828	/* handle this in 4 parts */
		1829	/* FBs */
		1830	if (card_res->count_fbs >= fb_count) {
		1831	copied = 0;
		1832	fb_id = (uint32_t __user *)(unsigned long)card_res->fb_id_ptr;
		1833	list_for_each_entry(fb, &file_priv->fbs, filp_head) {
		1834	if (put_user(fb->base.id, fb_id + copied)) {
		1835	mutex_unlock(&file_priv->fbs_lock);
		1836	return -EFAULT;
		1837	}
		1838	copied++;
		1839	}
		1840	}
		1841	card_res->count_fbs = fb_count;
		1842	mutex_unlock(&file_priv->fbs_lock);
		1843
5271	serge	1844	/* mode_config.mutex protects the connector list against e.g. DP MST
		1845	* connector hot-adding. CRTC/Plane lists are invariant. */
		1846	mutex_lock(&dev->mode_config.mutex);
6084	serge	1847	drm_for_each_crtc(crtc, dev)
		1848	crtc_count++;
1123	serge	1849
6084	serge	1850	drm_for_each_connector(connector, dev)
		1851	connector_count++;
1123	serge	1852
6084	serge	1853	drm_for_each_encoder(encoder, dev)
		1854	encoder_count++;
1123	serge	1855
		1856	card_res->max_height = dev->mode_config.max_height;
		1857	card_res->min_height = dev->mode_config.min_height;
		1858	card_res->max_width = dev->mode_config.max_width;
		1859	card_res->min_width = dev->mode_config.min_width;
		1860
		1861	/* CRTCs */
		1862	if (card_res->count_crtcs >= crtc_count) {
		1863	copied = 0;
		1864	crtc_id = (uint32_t __user *)(unsigned long)card_res->crtc_id_ptr;
6084	serge	1865	drm_for_each_crtc(crtc, dev) {
6937	serge	1866	DRM_DEBUG_KMS("[CRTC:%d:%s]\n",
		1867	crtc->base.id, crtc->name);
6084	serge	1868	if (put_user(crtc->base.id, crtc_id + copied)) {
		1869	ret = -EFAULT;
		1870	goto out;
1123	serge	1871	}
6084	serge	1872	copied++;
1123	serge	1873	}
		1874	}
		1875	card_res->count_crtcs = crtc_count;
		1876
		1877	/* Encoders */
		1878	if (card_res->count_encoders >= encoder_count) {
		1879	copied = 0;
		1880	encoder_id = (uint32_t __user *)(unsigned long)card_res->encoder_id_ptr;
6084	serge	1881	drm_for_each_encoder(encoder, dev) {
		1882	DRM_DEBUG_KMS("[ENCODER:%d:%s]\n", encoder->base.id,
		1883	encoder->name);
		1884	if (put_user(encoder->base.id, encoder_id +
		1885	copied)) {
		1886	ret = -EFAULT;
		1887	goto out;
1123	serge	1888	}
6084	serge	1889	copied++;
1123	serge	1890	}
		1891	}
		1892	card_res->count_encoders = encoder_count;
		1893
		1894	/* Connectors */
		1895	if (card_res->count_connectors >= connector_count) {
		1896	copied = 0;
		1897	connector_id = (uint32_t __user *)(unsigned long)card_res->connector_id_ptr;
6084	serge	1898	drm_for_each_connector(connector, dev) {
		1899	DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n",
		1900	connector->base.id,
		1901	connector->name);
		1902	if (put_user(connector->base.id,
		1903	connector_id + copied)) {
		1904	ret = -EFAULT;
		1905	goto out;
1123	serge	1906	}
6084	serge	1907	copied++;
1123	serge	1908	}
		1909	}
		1910	card_res->count_connectors = connector_count;
		1911
1963	serge	1912	DRM_DEBUG_KMS("CRTC[%d] CONNECTORS[%d] ENCODERS[%d]\n", card_res->count_crtcs,
1123	serge	1913	card_res->count_connectors, card_res->count_encoders);
		1914
		1915	out:
5271	serge	1916	mutex_unlock(&dev->mode_config.mutex);
1123	serge	1917	return ret;
		1918	}
		1919
		1920	/**
		1921	* drm_mode_getcrtc - get CRTC configuration
3480	Serge	1922	* @dev: drm device for the ioctl
		1923	* @data: data pointer for the ioctl
		1924	* @file_priv: drm file for the ioctl call
1123	serge	1925	*
		1926	* Construct a CRTC configuration structure to return to the user.
		1927	*
		1928	* Called by the user via ioctl.
		1929	*
5060	serge	1930	* Returns:
5271	serge	1931	* Zero on success, negative errno on failure.
1123	serge	1932	*/
		1933	int drm_mode_getcrtc(struct drm_device *dev,
		1934	void data, struct drm_file file_priv)
		1935	{
		1936	struct drm_mode_crtc *crtc_resp = data;
		1937	struct drm_crtc *crtc;
		1938
1963	serge	1939	if (!drm_core_check_feature(dev, DRIVER_MODESET))
		1940	return -EINVAL;
		1941
5060	serge	1942	crtc = drm_crtc_find(dev, crtc_resp->crtc_id);
5271	serge	1943	if (!crtc)
		1944	return -ENOENT;
1123	serge	1945
5271	serge	1946	drm_modeset_lock_crtc(crtc, crtc->primary);
1123	serge	1947	crtc_resp->gamma_size = crtc->gamma_size;
5060	serge	1948	if (crtc->primary->fb)
		1949	crtc_resp->fb_id = crtc->primary->fb->base.id;
1123	serge	1950	else
		1951	crtc_resp->fb_id = 0;
		1952
6084	serge	1953	if (crtc->state) {
		1954	crtc_resp->x = crtc->primary->state->src_x >> 16;
		1955	crtc_resp->y = crtc->primary->state->src_y >> 16;
		1956	if (crtc->state->enable) {
		1957	drm_mode_convert_to_umode(&crtc_resp->mode, &crtc->state->mode);
		1958	crtc_resp->mode_valid = 1;
1123	serge	1959
6084	serge	1960	} else {
		1961	crtc_resp->mode_valid = 0;
		1962	}
		1963	} else {
		1964	crtc_resp->x = crtc->x;
		1965	crtc_resp->y = crtc->y;
		1966	if (crtc->enabled) {
		1967	drm_mode_convert_to_umode(&crtc_resp->mode, &crtc->mode);
		1968	crtc_resp->mode_valid = 1;
1123	serge	1969
6084	serge	1970	} else {
		1971	crtc_resp->mode_valid = 0;
		1972	}
1123	serge	1973	}
5271	serge	1974	drm_modeset_unlock_crtc(crtc);
1123	serge	1975
5271	serge	1976	return 0;
1123	serge	1977	}
		1978
4560	Serge	1979	static bool drm_mode_expose_to_userspace(const struct drm_display_mode *mode,
		1980	const struct drm_file *file_priv)
		1981	{
		1982	/*
		1983	* If user-space hasn't configured the driver to expose the stereo 3D
		1984	* modes, don't expose them.
		1985	*/
		1986	if (!file_priv->stereo_allowed && drm_mode_is_stereo(mode))
		1987	return false;
		1988
		1989	return true;
		1990	}
		1991
5271	serge	1992	static struct drm_encoder drm_connector_get_encoder(struct drm_connector connector)
		1993	{
		1994	/* For atomic drivers only state objects are synchronously updated and
		1995	* protected by modeset locks, so check those first. */
		1996	if (connector->state)
		1997	return connector->state->best_encoder;
		1998	return connector->encoder;
		1999	}
		2000
6084	serge	2001	/* helper for getconnector and getproperties ioctls */
		2002	static int get_properties(struct drm_mode_object *obj, bool atomic,
		2003	uint32_t __user prop_ptr, uint64_t __user prop_values,
		2004	uint32_t *arg_count_props)
		2005	{
		2006	int props_count;
		2007	int i, ret, copied;
		2008
		2009	props_count = obj->properties->count;
		2010	if (!atomic)
		2011	props_count -= obj->properties->atomic_count;
		2012
		2013	if ((*arg_count_props >= props_count) && props_count) {
		2014	for (i = 0, copied = 0; copied < props_count; i++) {
		2015	struct drm_property *prop = obj->properties->properties[i];
		2016	uint64_t val;
		2017
		2018	if ((prop->flags & DRM_MODE_PROP_ATOMIC) && !atomic)
		2019	continue;
		2020
		2021	ret = drm_object_property_get_value(obj, prop, &val);
		2022	if (ret)
		2023	return ret;
		2024
		2025	if (put_user(prop->base.id, prop_ptr + copied))
		2026	return -EFAULT;
		2027
		2028	if (put_user(val, prop_values + copied))
		2029	return -EFAULT;
		2030
		2031	copied++;
		2032	}
		2033	}
		2034	*arg_count_props = props_count;
		2035
		2036	return 0;
		2037	}
		2038
1123	serge	2039	/**
		2040	* drm_mode_getconnector - get connector configuration
3480	Serge	2041	* @dev: drm device for the ioctl
		2042	* @data: data pointer for the ioctl
		2043	* @file_priv: drm file for the ioctl call
1123	serge	2044	*
		2045	* Construct a connector configuration structure to return to the user.
		2046	*
		2047	* Called by the user via ioctl.
		2048	*
5060	serge	2049	* Returns:
5271	serge	2050	* Zero on success, negative errno on failure.
1123	serge	2051	*/
		2052	int drm_mode_getconnector(struct drm_device dev, void data,
		2053	struct drm_file *file_priv)
		2054	{
		2055	struct drm_mode_get_connector *out_resp = data;
		2056	struct drm_connector *connector;
5271	serge	2057	struct drm_encoder *encoder;
1123	serge	2058	struct drm_display_mode *mode;
		2059	int mode_count = 0;
		2060	int encoders_count = 0;
		2061	int ret = 0;
		2062	int copied = 0;
		2063	int i;
		2064	struct drm_mode_modeinfo u_mode;
		2065	struct drm_mode_modeinfo __user *mode_ptr;
		2066	uint32_t __user *encoder_ptr;
		2067
1963	serge	2068	if (!drm_core_check_feature(dev, DRIVER_MODESET))
		2069	return -EINVAL;
		2070
1123	serge	2071	memset(&u_mode, 0, sizeof(struct drm_mode_modeinfo));
		2072
1963	serge	2073	DRM_DEBUG_KMS("[CONNECTOR:%d:?]\n", out_resp->connector_id);
1123	serge	2074
		2075	mutex_lock(&dev->mode_config.mutex);
		2076
5060	serge	2077	connector = drm_connector_find(dev, out_resp->connector_id);
		2078	if (!connector) {
4560	Serge	2079	ret = -ENOENT;
6084	serge	2080	goto out_unlock;
1123	serge	2081	}
		2082
6084	serge	2083	for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++)
		2084	if (connector->encoder_ids[i] != 0)
1123	serge	2085	encoders_count++;
		2086
		2087	if (out_resp->count_modes == 0) {
		2088	connector->funcs->fill_modes(connector,
		2089	dev->mode_config.max_width,
		2090	dev->mode_config.max_height);
		2091	}
		2092
		2093	/* delayed so we get modes regardless of pre-fill_modes state */
		2094	list_for_each_entry(mode, &connector->modes, head)
4560	Serge	2095	if (drm_mode_expose_to_userspace(mode, file_priv))
6084	serge	2096	mode_count++;
1123	serge	2097
		2098	out_resp->connector_id = connector->base.id;
		2099	out_resp->connector_type = connector->connector_type;
		2100	out_resp->connector_type_id = connector->connector_type_id;
		2101	out_resp->mm_width = connector->display_info.width_mm;
		2102	out_resp->mm_height = connector->display_info.height_mm;
		2103	out_resp->subpixel = connector->display_info.subpixel_order;
		2104	out_resp->connection = connector->status;
6084	serge	2105
5060	serge	2106	drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
5271	serge	2107	encoder = drm_connector_get_encoder(connector);
		2108	if (encoder)
		2109	out_resp->encoder_id = encoder->base.id;
1123	serge	2110	else
		2111	out_resp->encoder_id = 0;
		2112
		2113	/*
		2114	* This ioctl is called twice, once to determine how much space is
		2115	* needed, and the 2nd time to fill it.
		2116	*/
		2117	if ((out_resp->count_modes >= mode_count) && mode_count) {
		2118	copied = 0;
3031	serge	2119	mode_ptr = (struct drm_mode_modeinfo __user *)(unsigned long)out_resp->modes_ptr;
1123	serge	2120	list_for_each_entry(mode, &connector->modes, head) {
4560	Serge	2121	if (!drm_mode_expose_to_userspace(mode, file_priv))
		2122	continue;
		2123
6084	serge	2124	drm_mode_convert_to_umode(&u_mode, mode);
1123	serge	2125	if (copy_to_user(mode_ptr + copied,
		2126	&u_mode, sizeof(u_mode))) {
		2127	ret = -EFAULT;
		2128	goto out;
		2129	}
		2130	copied++;
		2131	}
		2132	}
		2133	out_resp->count_modes = mode_count;
		2134
6084	serge	2135	ret = get_properties(&connector->base, file_priv->atomic,
		2136	(uint32_t __user *)(unsigned long)(out_resp->props_ptr),
		2137	(uint64_t __user *)(unsigned long)(out_resp->prop_values_ptr),
		2138	&out_resp->count_props);
		2139	if (ret)
		2140	goto out;
1123	serge	2141
		2142	if ((out_resp->count_encoders >= encoders_count) && encoders_count) {
		2143	copied = 0;
3031	serge	2144	encoder_ptr = (uint32_t __user *)(unsigned long)(out_resp->encoders_ptr);
1123	serge	2145	for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
		2146	if (connector->encoder_ids[i] != 0) {
		2147	if (put_user(connector->encoder_ids[i],
		2148	encoder_ptr + copied)) {
		2149	ret = -EFAULT;
		2150	goto out;
		2151	}
		2152	copied++;
		2153	}
		2154	}
		2155	}
		2156	out_resp->count_encoders = encoders_count;
		2157
		2158	out:
6084	serge	2159	drm_modeset_unlock(&dev->mode_config.connection_mutex);
		2160
		2161	out_unlock:
1123	serge	2162	mutex_unlock(&dev->mode_config.mutex);
3480	Serge	2163
1123	serge	2164	return ret;
		2165	}
		2166
5271	serge	2167	static struct drm_crtc drm_encoder_get_crtc(struct drm_encoder encoder)
		2168	{
		2169	struct drm_connector *connector;
		2170	struct drm_device *dev = encoder->dev;
		2171	bool uses_atomic = false;
		2172
		2173	/* For atomic drivers only state objects are synchronously updated and
		2174	* protected by modeset locks, so check those first. */
6084	serge	2175	drm_for_each_connector(connector, dev) {
5271	serge	2176	if (!connector->state)
		2177	continue;
		2178
		2179	uses_atomic = true;
		2180
		2181	if (connector->state->best_encoder != encoder)
		2182	continue;
		2183
		2184	return connector->state->crtc;
		2185	}
		2186
		2187	/* Don't return stale data (e.g. pending async disable). */
		2188	if (uses_atomic)
		2189	return NULL;
		2190
		2191	return encoder->crtc;
		2192	}
		2193
5060	serge	2194	/**
		2195	* drm_mode_getencoder - get encoder configuration
		2196	* @dev: drm device for the ioctl
		2197	* @data: data pointer for the ioctl
		2198	* @file_priv: drm file for the ioctl call
		2199	*
		2200	* Construct a encoder configuration structure to return to the user.
		2201	*
		2202	* Called by the user via ioctl.
		2203	*
		2204	* Returns:
5271	serge	2205	* Zero on success, negative errno on failure.
5060	serge	2206	*/
1123	serge	2207	int drm_mode_getencoder(struct drm_device dev, void data,
		2208	struct drm_file *file_priv)
		2209	{
		2210	struct drm_mode_get_encoder *enc_resp = data;
		2211	struct drm_encoder *encoder;
5271	serge	2212	struct drm_crtc *crtc;
1123	serge	2213
1963	serge	2214	if (!drm_core_check_feature(dev, DRIVER_MODESET))
		2215	return -EINVAL;
		2216
5060	serge	2217	encoder = drm_encoder_find(dev, enc_resp->encoder_id);
5271	serge	2218	if (!encoder)
		2219	return -ENOENT;
1123	serge	2220
5271	serge	2221	drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
		2222	crtc = drm_encoder_get_crtc(encoder);
		2223	if (crtc)
		2224	enc_resp->crtc_id = crtc->base.id;
1123	serge	2225	else
		2226	enc_resp->crtc_id = 0;
5271	serge	2227	drm_modeset_unlock(&dev->mode_config.connection_mutex);
		2228
1123	serge	2229	enc_resp->encoder_type = encoder->encoder_type;
		2230	enc_resp->encoder_id = encoder->base.id;
		2231	enc_resp->possible_crtcs = encoder->possible_crtcs;
		2232	enc_resp->possible_clones = encoder->possible_clones;
		2233
5271	serge	2234	return 0;
1123	serge	2235	}
		2236
		2237	/**
5060	serge	2238	* drm_mode_getplane_res - enumerate all plane resources
3031	serge	2239	* @dev: DRM device
		2240	* @data: ioctl data
		2241	* @file_priv: DRM file info
		2242	*
5060	serge	2243	* Construct a list of plane ids to return to the user.
		2244	*
		2245	* Called by the user via ioctl.
		2246	*
		2247	* Returns:
5271	serge	2248	* Zero on success, negative errno on failure.
3031	serge	2249	*/
		2250	int drm_mode_getplane_res(struct drm_device dev, void data,
6084	serge	2251	struct drm_file *file_priv)
3031	serge	2252	{
		2253	struct drm_mode_get_plane_res *plane_resp = data;
		2254	struct drm_mode_config *config;
		2255	struct drm_plane *plane;
		2256	uint32_t __user *plane_ptr;
5271	serge	2257	int copied = 0;
5060	serge	2258	unsigned num_planes;
3031	serge	2259
		2260	if (!drm_core_check_feature(dev, DRIVER_MODESET))
		2261	return -EINVAL;
		2262
		2263	config = &dev->mode_config;
		2264
5060	serge	2265	if (file_priv->universal_planes)
		2266	num_planes = config->num_total_plane;
		2267	else
		2268	num_planes = config->num_overlay_plane;
		2269
3031	serge	2270	/*
		2271	* This ioctl is called twice, once to determine how much space is
		2272	* needed, and the 2nd time to fill it.
		2273	*/
5060	serge	2274	if (num_planes &&
		2275	(plane_resp->count_planes >= num_planes)) {
3031	serge	2276	plane_ptr = (uint32_t __user *)(unsigned long)plane_resp->plane_id_ptr;
		2277
5271	serge	2278	/* Plane lists are invariant, no locking needed. */
6084	serge	2279	drm_for_each_plane(plane, dev) {
5060	serge	2280	/*
		2281	* Unless userspace set the 'universal planes'
		2282	* capability bit, only advertise overlays.
		2283	*/
		2284	if (plane->type != DRM_PLANE_TYPE_OVERLAY &&
		2285	!file_priv->universal_planes)
		2286	continue;
		2287
5271	serge	2288	if (put_user(plane->base.id, plane_ptr + copied))
		2289	return -EFAULT;
3031	serge	2290	copied++;
		2291	}
		2292	}
5060	serge	2293	plane_resp->count_planes = num_planes;
3031	serge	2294
5271	serge	2295	return 0;
3031	serge	2296	}
		2297
		2298	/**
5060	serge	2299	* drm_mode_getplane - get plane configuration
3031	serge	2300	* @dev: DRM device
		2301	* @data: ioctl data
		2302	* @file_priv: DRM file info
		2303	*
5060	serge	2304	* Construct a plane configuration structure to return to the user.
		2305	*
		2306	* Called by the user via ioctl.
		2307	*
		2308	* Returns:
5271	serge	2309	* Zero on success, negative errno on failure.
3031	serge	2310	*/
		2311	int drm_mode_getplane(struct drm_device dev, void data,
6084	serge	2312	struct drm_file *file_priv)
3031	serge	2313	{
		2314	struct drm_mode_get_plane *plane_resp = data;
		2315	struct drm_plane *plane;
		2316	uint32_t __user *format_ptr;
		2317
		2318	if (!drm_core_check_feature(dev, DRIVER_MODESET))
		2319	return -EINVAL;
		2320
5060	serge	2321	plane = drm_plane_find(dev, plane_resp->plane_id);
5271	serge	2322	if (!plane)
		2323	return -ENOENT;
3031	serge	2324
5271	serge	2325	drm_modeset_lock(&plane->mutex, NULL);
3031	serge	2326	if (plane->crtc)
		2327	plane_resp->crtc_id = plane->crtc->base.id;
		2328	else
		2329	plane_resp->crtc_id = 0;
		2330
		2331	if (plane->fb)
		2332	plane_resp->fb_id = plane->fb->base.id;
		2333	else
		2334	plane_resp->fb_id = 0;
5271	serge	2335	drm_modeset_unlock(&plane->mutex);
3031	serge	2336
		2337	plane_resp->plane_id = plane->base.id;
		2338	plane_resp->possible_crtcs = plane->possible_crtcs;
4075	Serge	2339	plane_resp->gamma_size = 0;
3031	serge	2340
		2341	/*
		2342	* This ioctl is called twice, once to determine how much space is
		2343	* needed, and the 2nd time to fill it.
		2344	*/
		2345	if (plane->format_count &&
		2346	(plane_resp->count_format_types >= plane->format_count)) {
		2347	format_ptr = (uint32_t __user *)(unsigned long)plane_resp->format_type_ptr;
		2348	if (copy_to_user(format_ptr,
		2349	plane->format_types,
		2350	sizeof(uint32_t) * plane->format_count)) {
5271	serge	2351	return -EFAULT;
3031	serge	2352	}
		2353	}
		2354	plane_resp->count_format_types = plane->format_count;
		2355
5271	serge	2356	return 0;
3031	serge	2357	}
6084	serge	2358	#endif
3031	serge	2359
6084	serge	2360	/**
		2361	* drm_plane_check_pixel_format - Check if the plane supports the pixel format
		2362	* @plane: plane to check for format support
		2363	* @format: the pixel format
		2364	*
		2365	* Returns:
		2366	* Zero of @plane has @format in its list of supported pixel formats, -EINVAL
		2367	* otherwise.
		2368	*/
		2369	int drm_plane_check_pixel_format(const struct drm_plane *plane, u32 format)
		2370	{
		2371	unsigned int i;
		2372
		2373	for (i = 0; i < plane->format_count; i++) {
		2374	if (format == plane->format_types[i])
		2375	return 0;
		2376	}
		2377
		2378	return -EINVAL;
		2379	}
		2380
		2381	static int check_src_coords(uint32_t src_x, uint32_t src_y,
		2382	uint32_t src_w, uint32_t src_h,
		2383	const struct drm_framebuffer *fb)
		2384	{
		2385	unsigned int fb_width, fb_height;
		2386
		2387	fb_width = fb->width << 16;
		2388	fb_height = fb->height << 16;
		2389
		2390	/* Make sure source coordinates are inside the fb. */
		2391	if (src_w > fb_width \|\|
		2392	src_x > fb_width - src_w \|\|
		2393	src_h > fb_height \|\|
		2394	src_y > fb_height - src_h) {
		2395	DRM_DEBUG_KMS("Invalid source coordinates "
		2396	"%u.%06ux%u.%06u+%u.%06u+%u.%06u\n",
		2397	src_w >> 16, ((src_w & 0xffff) * 15625) >> 10,
		2398	src_h >> 16, ((src_h & 0xffff) * 15625) >> 10,
		2399	src_x >> 16, ((src_x & 0xffff) * 15625) >> 10,
		2400	src_y >> 16, ((src_y & 0xffff) * 15625) >> 10);
		2401	return -ENOSPC;
		2402	}
		2403
		2404	return 0;
		2405	}
		2406
5060	serge	2407	/*
		2408	* setplane_internal - setplane handler for internal callers
3031	serge	2409	*
5060	serge	2410	* Note that we assume an extra reference has already been taken on fb. If the
		2411	* update fails, this reference will be dropped before return; if it succeeds,
		2412	* the previous framebuffer (if any) will be unreferenced instead.
		2413	*
		2414	* src_{x,y,w,h} are provided in 16.16 fixed point format
3031	serge	2415	*/
5271	serge	2416	static int __setplane_internal(struct drm_plane *plane,
6084	serge	2417	struct drm_crtc *crtc,
		2418	struct drm_framebuffer *fb,
		2419	int32_t crtc_x, int32_t crtc_y,
		2420	uint32_t crtc_w, uint32_t crtc_h,
		2421	/* src_{x,y,w,h} values are 16.16 fixed point */
		2422	uint32_t src_x, uint32_t src_y,
		2423	uint32_t src_w, uint32_t src_h)
3031	serge	2424	{
		2425	int ret = 0;
		2426
		2427	/* No fb means shut it down */
5060	serge	2428	if (!fb) {
5271	serge	2429	plane->old_fb = plane->fb;
5060	serge	2430	ret = plane->funcs->disable_plane(plane);
		2431	if (!ret) {
6084	serge	2432	plane->crtc = NULL;
		2433	plane->fb = NULL;
5060	serge	2434	} else {
5271	serge	2435	plane->old_fb = NULL;
5060	serge	2436	}
3031	serge	2437	goto out;
		2438	}
		2439
5060	serge	2440	/* Check whether this plane is usable on this CRTC */
		2441	if (!(plane->possible_crtcs & drm_crtc_mask(crtc))) {
		2442	DRM_DEBUG_KMS("Invalid crtc for plane\n");
		2443	ret = -EINVAL;
3031	serge	2444	goto out;
		2445	}
		2446
		2447	/* Check whether this plane supports the fb pixel format. */
6084	serge	2448	ret = drm_plane_check_pixel_format(plane, fb->pixel_format);
		2449	if (ret) {
4075	Serge	2450	DRM_DEBUG_KMS("Invalid pixel format %s\n",
		2451	drm_get_format_name(fb->pixel_format));
3031	serge	2452	goto out;
		2453	}
		2454
6084	serge	2455	/* Give drivers some help against integer overflows */
		2456	if (crtc_w > INT_MAX \|\|
		2457	crtc_x > INT_MAX - (int32_t) crtc_w \|\|
		2458	crtc_h > INT_MAX \|\|
		2459	crtc_y > INT_MAX - (int32_t) crtc_h) {
		2460	DRM_DEBUG_KMS("Invalid CRTC coordinates %ux%u+%d+%d\n",
		2461	crtc_w, crtc_h, crtc_x, crtc_y);
		2462	ret = -ERANGE;
3031	serge	2463	goto out;
		2464	}
		2465
6084	serge	2466	ret = check_src_coords(src_x, src_y, src_w, src_h, fb);
		2467	if (ret)
		2468	goto out;
		2469
5271	serge	2470	plane->old_fb = plane->fb;
3031	serge	2471	ret = plane->funcs->update_plane(plane, crtc, fb,
5060	serge	2472	crtc_x, crtc_y, crtc_w, crtc_h,
		2473	src_x, src_y, src_w, src_h);
3031	serge	2474	if (!ret) {
		2475	plane->crtc = crtc;
		2476	plane->fb = fb;
3480	Serge	2477	fb = NULL;
5060	serge	2478	} else {
5271	serge	2479	plane->old_fb = NULL;
3031	serge	2480	}
		2481
		2482	out:
3480	Serge	2483	if (fb)
		2484	drm_framebuffer_unreference(fb);
5271	serge	2485	if (plane->old_fb)
		2486	drm_framebuffer_unreference(plane->old_fb);
		2487	plane->old_fb = NULL;
3031	serge	2488
		2489	return ret;
5271	serge	2490	}
5060	serge	2491
5271	serge	2492	static int setplane_internal(struct drm_plane *plane,
		2493	struct drm_crtc *crtc,
		2494	struct drm_framebuffer *fb,
		2495	int32_t crtc_x, int32_t crtc_y,
		2496	uint32_t crtc_w, uint32_t crtc_h,
		2497	/* src_{x,y,w,h} values are 16.16 fixed point */
		2498	uint32_t src_x, uint32_t src_y,
		2499	uint32_t src_w, uint32_t src_h)
		2500	{
		2501	int ret;
		2502
		2503	drm_modeset_lock_all(plane->dev);
		2504	ret = __setplane_internal(plane, crtc, fb,
		2505	crtc_x, crtc_y, crtc_w, crtc_h,
		2506	src_x, src_y, src_w, src_h);
		2507	drm_modeset_unlock_all(plane->dev);
		2508
		2509	return ret;
3031	serge	2510	}
5060	serge	2511
		2512	/**
		2513	* drm_mode_setplane - configure a plane's configuration
		2514	* @dev: DRM device
		2515	* @data: ioctl data*
		2516	* @file_priv: DRM file info
		2517	*
		2518	* Set plane configuration, including placement, fb, scaling, and other factors.
		2519	* Or pass a NULL fb to disable (planes may be disabled without providing a
		2520	* valid crtc).
		2521	*
		2522	* Returns:
5271	serge	2523	* Zero on success, negative errno on failure.
5060	serge	2524	*/
		2525	int drm_mode_setplane(struct drm_device dev, void data,
		2526	struct drm_file *file_priv)
		2527	{
		2528	struct drm_mode_set_plane *plane_req = data;
		2529	struct drm_plane *plane;
		2530	struct drm_crtc *crtc = NULL;
		2531	struct drm_framebuffer *fb = NULL;
		2532
		2533	if (!drm_core_check_feature(dev, DRIVER_MODESET))
		2534	return -EINVAL;
		2535
		2536	/*
		2537	* First, find the plane, crtc, and fb objects. If not available,
		2538	* we don't bother to call the driver.
		2539	*/
5271	serge	2540	plane = drm_plane_find(dev, plane_req->plane_id);
		2541	if (!plane) {
5060	serge	2542	DRM_DEBUG_KMS("Unknown plane ID %d\n",
		2543	plane_req->plane_id);
		2544	return -ENOENT;
		2545	}
		2546
		2547	if (plane_req->fb_id) {
		2548	fb = drm_framebuffer_lookup(dev, plane_req->fb_id);
		2549	if (!fb) {
		2550	DRM_DEBUG_KMS("Unknown framebuffer ID %d\n",
		2551	plane_req->fb_id);
		2552	return -ENOENT;
		2553	}
		2554
5271	serge	2555	crtc = drm_crtc_find(dev, plane_req->crtc_id);
		2556	if (!crtc) {
5060	serge	2557	DRM_DEBUG_KMS("Unknown crtc ID %d\n",
		2558	plane_req->crtc_id);
		2559	return -ENOENT;
		2560	}
		2561	}
		2562
		2563	/*
		2564	* setplane_internal will take care of deref'ing either the old or new
		2565	* framebuffer depending on success.
		2566	*/
		2567	return setplane_internal(plane, crtc, fb,
		2568	plane_req->crtc_x, plane_req->crtc_y,
		2569	plane_req->crtc_w, plane_req->crtc_h,
		2570	plane_req->src_x, plane_req->src_y,
		2571	plane_req->src_w, plane_req->src_h);
		2572	}
3031	serge	2573
		2574	/**
3480	Serge	2575	* drm_mode_set_config_internal - helper to call ->set_config
		2576	* @set: modeset config to set
		2577	*
		2578	* This is a little helper to wrap internal calls to the ->set_config driver
		2579	* interface. The only thing it adds is correct refcounting dance.
5060	serge	2580	*
		2581	* Returns:
5271	serge	2582	* Zero on success, negative errno on failure.
3480	Serge	2583	*/
		2584	int drm_mode_set_config_internal(struct drm_mode_set *set)
		2585	{
		2586	struct drm_crtc *crtc = set->crtc;
4075	Serge	2587	struct drm_framebuffer *fb;
		2588	struct drm_crtc *tmp;
3480	Serge	2589	int ret;
		2590
4075	Serge	2591	/*
		2592	* NOTE: ->set_config can also disable other crtcs (if we steal all
		2593	* connectors from it), hence we need to refcount the fbs across all
		2594	* crtcs. Atomic modeset will have saner semantics ...
		2595	*/
6084	serge	2596	drm_for_each_crtc(tmp, crtc->dev)
5271	serge	2597	tmp->primary->old_fb = tmp->primary->fb;
4075	Serge	2598
3480	Serge	2599	fb = set->fb;
		2600
		2601	ret = crtc->funcs->set_config(set);
		2602	if (ret == 0) {
5060	serge	2603	crtc->primary->crtc = crtc;
		2604	crtc->primary->fb = fb;
3480	Serge	2605	}
		2606
6084	serge	2607	drm_for_each_crtc(tmp, crtc->dev) {
5060	serge	2608	if (tmp->primary->fb)
		2609	drm_framebuffer_reference(tmp->primary->fb);
6283	serge	2610	if (tmp->primary->old_fb)
		2611	drm_framebuffer_unreference(tmp->primary->old_fb);
		2612	tmp->primary->old_fb = NULL;
4075	Serge	2613	}
		2614
3480	Serge	2615	return ret;
		2616	}
		2617	EXPORT_SYMBOL(drm_mode_set_config_internal);
		2618
5060	serge	2619	/**
6084	serge	2620	* drm_crtc_get_hv_timing - Fetches hdisplay/vdisplay for given mode
		2621	* @mode: mode to query
		2622	* @hdisplay: hdisplay value to fill in
		2623	* @vdisplay: vdisplay value to fill in
		2624	*
		2625	* The vdisplay value will be doubled if the specified mode is a stereo mode of
		2626	* the appropriate layout.
		2627	*/
		2628	void drm_crtc_get_hv_timing(const struct drm_display_mode *mode,
		2629	int hdisplay, int vdisplay)
		2630	{
		2631	struct drm_display_mode adjusted;
		2632
		2633	drm_mode_copy(&adjusted, mode);
		2634	drm_mode_set_crtcinfo(&adjusted, CRTC_STEREO_DOUBLE_ONLY);
		2635	*hdisplay = adjusted.crtc_hdisplay;
		2636	*vdisplay = adjusted.crtc_vdisplay;
		2637	}
		2638	EXPORT_SYMBOL(drm_crtc_get_hv_timing);
		2639
		2640	/**
5060	serge	2641	* drm_crtc_check_viewport - Checks that a framebuffer is big enough for the
		2642	* CRTC viewport
		2643	* @crtc: CRTC that framebuffer will be displayed on
		2644	* @x: x panning
		2645	* @y: y panning
		2646	* @mode: mode that framebuffer will be displayed under
		2647	* @fb: framebuffer to check size of
4560	Serge	2648	*/
5060	serge	2649	int drm_crtc_check_viewport(const struct drm_crtc *crtc,
6084	serge	2650	int x, int y,
		2651	const struct drm_display_mode *mode,
		2652	const struct drm_framebuffer *fb)
4560	Serge	2653
		2654	{
		2655	int hdisplay, vdisplay;
		2656
6084	serge	2657	drm_crtc_get_hv_timing(mode, &hdisplay, &vdisplay);
4560	Serge	2658
6084	serge	2659	if (crtc->state &&
		2660	crtc->primary->state->rotation & (BIT(DRM_ROTATE_90) \|
		2661	BIT(DRM_ROTATE_270)))
4560	Serge	2662	swap(hdisplay, vdisplay);
		2663
6084	serge	2664	return check_src_coords(x << 16, y << 16,
		2665	hdisplay << 16, vdisplay << 16, fb);
4560	Serge	2666	}
5060	serge	2667	EXPORT_SYMBOL(drm_crtc_check_viewport);
4560	Serge	2668
6084	serge	2669	#if 0
3480	Serge	2670	/**
1123	serge	2671	* drm_mode_setcrtc - set CRTC configuration
3480	Serge	2672	* @dev: drm device for the ioctl
		2673	* @data: data pointer for the ioctl
		2674	* @file_priv: drm file for the ioctl call
1123	serge	2675	*
		2676	* Build a new CRTC configuration based on user request.
		2677	*
		2678	* Called by the user via ioctl.
		2679	*
5060	serge	2680	* Returns:
5271	serge	2681	* Zero on success, negative errno on failure.
1123	serge	2682	*/
		2683	int drm_mode_setcrtc(struct drm_device dev, void data,
		2684	struct drm_file *file_priv)
		2685	{
		2686	struct drm_mode_config *config = &dev->mode_config;
		2687	struct drm_mode_crtc *crtc_req = data;
3031	serge	2688	struct drm_crtc *crtc;
1123	serge	2689	struct drm_connector *connector_set = NULL, connector;
		2690	struct drm_framebuffer *fb = NULL;
		2691	struct drm_display_mode *mode = NULL;
		2692	struct drm_mode_set set;
		2693	uint32_t __user *set_connectors_ptr;
3031	serge	2694	int ret;
1123	serge	2695	int i;
		2696
1963	serge	2697	if (!drm_core_check_feature(dev, DRIVER_MODESET))
		2698	return -EINVAL;
		2699
6084	serge	2700	/*
		2701	* Universal plane src offsets are only 16.16, prevent havoc for
		2702	* drivers using universal plane code internally.
		2703	*/
		2704	if (crtc_req->x & 0xffff0000 \|\| crtc_req->y & 0xffff0000)
3031	serge	2705	return -ERANGE;
		2706
3480	Serge	2707	drm_modeset_lock_all(dev);
5060	serge	2708	crtc = drm_crtc_find(dev, crtc_req->crtc_id);
		2709	if (!crtc) {
1179	serge	2710	DRM_DEBUG_KMS("Unknown CRTC ID %d\n", crtc_req->crtc_id);
4560	Serge	2711	ret = -ENOENT;
1123	serge	2712	goto out;
		2713	}
6937	serge	2714	DRM_DEBUG_KMS("[CRTC:%d:%s]\n", crtc->base.id, crtc->name);
1123	serge	2715
		2716	if (crtc_req->mode_valid) {
		2717	/* If we have a mode we need a framebuffer. */
		2718	/* If we pass -1, set the mode with the currently bound fb */
		2719	if (crtc_req->fb_id == -1) {
5060	serge	2720	if (!crtc->primary->fb) {
3031	serge	2721	DRM_DEBUG_KMS("CRTC doesn't have current FB\n");
		2722	ret = -EINVAL;
		2723	goto out;
		2724	}
5060	serge	2725	fb = crtc->primary->fb;
3480	Serge	2726	/* Make refcounting symmetric with the lookup path. */
		2727	drm_framebuffer_reference(fb);
1123	serge	2728	} else {
3480	Serge	2729	fb = drm_framebuffer_lookup(dev, crtc_req->fb_id);
		2730	if (!fb) {
1179	serge	2731	DRM_DEBUG_KMS("Unknown FB ID%d\n",
		2732	crtc_req->fb_id);
4560	Serge	2733	ret = -ENOENT;
1123	serge	2734	goto out;
		2735	}
		2736	}
		2737
		2738	mode = drm_mode_create(dev);
3031	serge	2739	if (!mode) {
		2740	ret = -ENOMEM;
		2741	goto out;
		2742	}
		2743
6084	serge	2744	ret = drm_mode_convert_umode(mode, &crtc_req->mode);
3031	serge	2745	if (ret) {
		2746	DRM_DEBUG_KMS("Invalid mode\n");
		2747	goto out;
		2748	}
		2749
6937	serge	2750	drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V);
		2751
6084	serge	2752	/*
		2753	* Check whether the primary plane supports the fb pixel format.
		2754	* Drivers not implementing the universal planes API use a
		2755	* default formats list provided by the DRM core which doesn't
		2756	* match real hardware capabilities. Skip the check in that
		2757	* case.
		2758	*/
		2759	if (!crtc->primary->format_default) {
		2760	ret = drm_plane_check_pixel_format(crtc->primary,
		2761	fb->pixel_format);
		2762	if (ret) {
		2763	DRM_DEBUG_KMS("Invalid pixel format %s\n",
		2764	drm_get_format_name(fb->pixel_format));
		2765	goto out;
		2766	}
		2767	}
		2768
4560	Serge	2769	ret = drm_crtc_check_viewport(crtc, crtc_req->x, crtc_req->y,
		2770	mode, fb);
		2771	if (ret)
		2772	goto out;
3031	serge	2773
1123	serge	2774	}
		2775
		2776	if (crtc_req->count_connectors == 0 && mode) {
1179	serge	2777	DRM_DEBUG_KMS("Count connectors is 0 but mode set\n");
1123	serge	2778	ret = -EINVAL;
		2779	goto out;
		2780	}
		2781
1179	serge	2782	if (crtc_req->count_connectors > 0 && (!mode \|\| !fb)) {
		2783	DRM_DEBUG_KMS("Count connectors is %d but no mode or fb set\n",
1123	serge	2784	crtc_req->count_connectors);
		2785	ret = -EINVAL;
		2786	goto out;
		2787	}
		2788
		2789	if (crtc_req->count_connectors > 0) {
		2790	u32 out_id;
		2791
		2792	/* Avoid unbounded kernel memory allocation */
		2793	if (crtc_req->count_connectors > config->num_connector) {
		2794	ret = -EINVAL;
		2795	goto out;
		2796	}
		2797
6084	serge	2798	connector_set = kmalloc_array(crtc_req->count_connectors,
		2799	sizeof(struct drm_connector *),
		2800	GFP_KERNEL);
1123	serge	2801	if (!connector_set) {
		2802	ret = -ENOMEM;
		2803	goto out;
		2804	}
		2805
		2806	for (i = 0; i < crtc_req->count_connectors; i++) {
3031	serge	2807	set_connectors_ptr = (uint32_t __user *)(unsigned long)crtc_req->set_connectors_ptr;
6660	serge	2808	if (get_user(out_id, &set_connectors_ptr[i])) {
		2809	ret = -EFAULT;
		2810	goto out;
		2811	}
1123	serge	2812
5060	serge	2813	connector = drm_connector_find(dev, out_id);
		2814	if (!connector) {
1179	serge	2815	DRM_DEBUG_KMS("Connector id %d unknown\n",
		2816	out_id);
4560	Serge	2817	ret = -ENOENT;
1123	serge	2818	goto out;
		2819	}
1963	serge	2820	DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n",
		2821	connector->base.id,
5060	serge	2822	connector->name);
1123	serge	2823
		2824	connector_set[i] = connector;
		2825	}
		2826	}
		2827
		2828	set.crtc = crtc;
		2829	set.x = crtc_req->x;
		2830	set.y = crtc_req->y;
		2831	set.mode = mode;
		2832	set.connectors = connector_set;
		2833	set.num_connectors = crtc_req->count_connectors;
1179	serge	2834	set.fb = fb;
3480	Serge	2835	ret = drm_mode_set_config_internal(&set);
1123	serge	2836
		2837	out:
3480	Serge	2838	if (fb)
		2839	drm_framebuffer_unreference(fb);
		2840
1123	serge	2841	kfree(connector_set);
3031	serge	2842	drm_mode_destroy(dev, mode);
3480	Serge	2843	drm_modeset_unlock_all(dev);
1123	serge	2844	return ret;
		2845	}
		2846
4075	Serge	2847	static int drm_mode_cursor_common(struct drm_device *dev,
		2848	struct drm_mode_cursor2 *req,
		2849	struct drm_file *file_priv)
1123	serge	2850	{
		2851	struct drm_crtc *crtc;
		2852	int ret = 0;
		2853
1963	serge	2854	if (!drm_core_check_feature(dev, DRIVER_MODESET))
		2855	return -EINVAL;
		2856
3031	serge	2857	if (!req->flags \|\| (~DRM_MODE_CURSOR_FLAGS & req->flags))
1123	serge	2858	return -EINVAL;
		2859
5060	serge	2860	crtc = drm_crtc_find(dev, req->crtc_id);
		2861	if (!crtc) {
1179	serge	2862	DRM_DEBUG_KMS("Unknown CRTC ID %d\n", req->crtc_id);
4560	Serge	2863	return -ENOENT;
1123	serge	2864	}
		2865
5060	serge	2866	/*
		2867	* If this crtc has a universal cursor plane, call that plane's update
		2868	* handler rather than using legacy cursor handlers.
		2869	*/
5271	serge	2870	drm_modeset_lock_crtc(crtc, crtc->cursor);
		2871	if (crtc->cursor) {
		2872	ret = drm_mode_cursor_universal(crtc, req, file_priv);
		2873	goto out;
		2874	}
5060	serge	2875
1123	serge	2876	if (req->flags & DRM_MODE_CURSOR_BO) {
4075	Serge	2877	if (!crtc->funcs->cursor_set && !crtc->funcs->cursor_set2) {
1123	serge	2878	ret = -ENXIO;
		2879	goto out;
		2880	}
		2881	/* Turns off the cursor if handle is 0 */
4075	Serge	2882	if (crtc->funcs->cursor_set2)
		2883	ret = crtc->funcs->cursor_set2(crtc, file_priv, req->handle,
		2884	req->width, req->height, req->hot_x, req->hot_y);
		2885	else
6084	serge	2886	ret = crtc->funcs->cursor_set(crtc, file_priv, req->handle,
		2887	req->width, req->height);
1123	serge	2888	}
		2889
		2890	if (req->flags & DRM_MODE_CURSOR_MOVE) {
		2891	if (crtc->funcs->cursor_move) {
		2892	ret = crtc->funcs->cursor_move(crtc, req->x, req->y);
		2893	} else {
		2894	ret = -EFAULT;
		2895	goto out;
		2896	}
		2897	}
		2898	out:
5271	serge	2899	drm_modeset_unlock_crtc(crtc);
3480	Serge	2900
1123	serge	2901	return ret;
4075	Serge	2902
1123	serge	2903	}
5060	serge	2904
		2905
		2906	/**
		2907	* drm_mode_cursor_ioctl - set CRTC's cursor configuration
		2908	* @dev: drm device for the ioctl
		2909	* @data: data pointer for the ioctl
		2910	* @file_priv: drm file for the ioctl call
		2911	*
		2912	* Set the cursor configuration based on user request.
		2913	*
		2914	* Called by the user via ioctl.
		2915	*
		2916	* Returns:
5271	serge	2917	* Zero on success, negative errno on failure.
5060	serge	2918	*/
4075	Serge	2919	int drm_mode_cursor_ioctl(struct drm_device *dev,
6084	serge	2920	void data, struct drm_file file_priv)
4075	Serge	2921	{
		2922	struct drm_mode_cursor *req = data;
		2923	struct drm_mode_cursor2 new_req;
		2924
		2925	memcpy(&new_req, req, sizeof(struct drm_mode_cursor));
		2926	new_req.hot_x = new_req.hot_y = 0;
		2927
		2928	return drm_mode_cursor_common(dev, &new_req, file_priv);
		2929	}
		2930
5060	serge	2931	/**
		2932	* drm_mode_cursor2_ioctl - set CRTC's cursor configuration
		2933	* @dev: drm device for the ioctl
		2934	* @data: data pointer for the ioctl
		2935	* @file_priv: drm file for the ioctl call
		2936	*
		2937	* Set the cursor configuration based on user request. This implements the 2nd
		2938	* version of the cursor ioctl, which allows userspace to additionally specify
		2939	* the hotspot of the pointer.
		2940	*
		2941	* Called by the user via ioctl.
		2942	*
		2943	* Returns:
5271	serge	2944	* Zero on success, negative errno on failure.
5060	serge	2945	*/
4075	Serge	2946	int drm_mode_cursor2_ioctl(struct drm_device *dev,
		2947	void data, struct drm_file file_priv)
		2948	{
		2949	struct drm_mode_cursor2 *req = data;
6084	serge	2950
4075	Serge	2951	return drm_mode_cursor_common(dev, req, file_priv);
		2952	}
3031	serge	2953	#endif
4560	Serge	2954
5060	serge	2955	/**
		2956	* drm_mode_legacy_fb_format - compute drm fourcc code from legacy description
		2957	* @bpp: bits per pixels
		2958	* @depth: bit depth per pixel
		2959	*
		2960	* Computes a drm fourcc pixel format code for the given @bpp/@depth values.
		2961	* Useful in fbdev emulation code, since that deals in those values.
		2962	*/
3031	serge	2963	uint32_t drm_mode_legacy_fb_format(uint32_t bpp, uint32_t depth)
		2964	{
		2965	uint32_t fmt;
1123	serge	2966
3031	serge	2967	switch (bpp) {
		2968	case 8:
3480	Serge	2969	fmt = DRM_FORMAT_C8;
3031	serge	2970	break;
		2971	case 16:
		2972	if (depth == 15)
		2973	fmt = DRM_FORMAT_XRGB1555;
		2974	else
		2975	fmt = DRM_FORMAT_RGB565;
		2976	break;
		2977	case 24:
		2978	fmt = DRM_FORMAT_RGB888;
		2979	break;
		2980	case 32:
		2981	if (depth == 24)
		2982	fmt = DRM_FORMAT_XRGB8888;
		2983	else if (depth == 30)
		2984	fmt = DRM_FORMAT_XRGB2101010;
		2985	else
		2986	fmt = DRM_FORMAT_ARGB8888;
		2987	break;
		2988	default:
		2989	DRM_ERROR("bad bpp, assuming x8r8g8b8 pixel format\n");
		2990	fmt = DRM_FORMAT_XRGB8888;
		2991	break;
		2992	}
		2993
		2994	return fmt;
		2995	}
		2996	EXPORT_SYMBOL(drm_mode_legacy_fb_format);
		2997	#if 0
1123	serge	2998	/**
		2999	* drm_mode_addfb - add an FB to the graphics configuration
3480	Serge	3000	* @dev: drm device for the ioctl
		3001	* @data: data pointer for the ioctl
		3002	* @file_priv: drm file for the ioctl call
1123	serge	3003	*
5060	serge	3004	* Add a new FB to the specified CRTC, given a user request. This is the
5271	serge	3005	* original addfb ioctl which only supported RGB formats.
1123	serge	3006	*
		3007	* Called by the user via ioctl.
		3008	*
5060	serge	3009	* Returns:
5271	serge	3010	* Zero on success, negative errno on failure.
1123	serge	3011	*/
		3012	int drm_mode_addfb(struct drm_device *dev,
		3013	void data, struct drm_file file_priv)
		3014	{
3031	serge	3015	struct drm_mode_fb_cmd *or = data;
		3016	struct drm_mode_fb_cmd2 r = {};
5271	serge	3017	int ret;
1123	serge	3018
5271	serge	3019	/* convert to new format and call new ioctl */
3031	serge	3020	r.fb_id = or->fb_id;
		3021	r.width = or->width;
		3022	r.height = or->height;
		3023	r.pitches[0] = or->pitch;
		3024	r.pixel_format = drm_mode_legacy_fb_format(or->bpp, or->depth);
		3025	r.handles[0] = or->handle;
		3026
5271	serge	3027	ret = drm_mode_addfb2(dev, &r, file_priv);
		3028	if (ret)
		3029	return ret;
1963	serge	3030
5271	serge	3031	or->fb_id = r.fb_id;
3031	serge	3032
5271	serge	3033	return 0;
3031	serge	3034	}
		3035
		3036	static int format_check(const struct drm_mode_fb_cmd2 *r)
		3037	{
		3038	uint32_t format = r->pixel_format & ~DRM_FORMAT_BIG_ENDIAN;
		3039
		3040	switch (format) {
		3041	case DRM_FORMAT_C8:
		3042	case DRM_FORMAT_RGB332:
		3043	case DRM_FORMAT_BGR233:
		3044	case DRM_FORMAT_XRGB4444:
		3045	case DRM_FORMAT_XBGR4444:
		3046	case DRM_FORMAT_RGBX4444:
		3047	case DRM_FORMAT_BGRX4444:
		3048	case DRM_FORMAT_ARGB4444:
		3049	case DRM_FORMAT_ABGR4444:
		3050	case DRM_FORMAT_RGBA4444:
		3051	case DRM_FORMAT_BGRA4444:
		3052	case DRM_FORMAT_XRGB1555:
		3053	case DRM_FORMAT_XBGR1555:
		3054	case DRM_FORMAT_RGBX5551:
		3055	case DRM_FORMAT_BGRX5551:
		3056	case DRM_FORMAT_ARGB1555:
		3057	case DRM_FORMAT_ABGR1555:
		3058	case DRM_FORMAT_RGBA5551:
		3059	case DRM_FORMAT_BGRA5551:
		3060	case DRM_FORMAT_RGB565:
		3061	case DRM_FORMAT_BGR565:
		3062	case DRM_FORMAT_RGB888:
		3063	case DRM_FORMAT_BGR888:
		3064	case DRM_FORMAT_XRGB8888:
		3065	case DRM_FORMAT_XBGR8888:
		3066	case DRM_FORMAT_RGBX8888:
		3067	case DRM_FORMAT_BGRX8888:
		3068	case DRM_FORMAT_ARGB8888:
		3069	case DRM_FORMAT_ABGR8888:
		3070	case DRM_FORMAT_RGBA8888:
		3071	case DRM_FORMAT_BGRA8888:
		3072	case DRM_FORMAT_XRGB2101010:
		3073	case DRM_FORMAT_XBGR2101010:
		3074	case DRM_FORMAT_RGBX1010102:
		3075	case DRM_FORMAT_BGRX1010102:
		3076	case DRM_FORMAT_ARGB2101010:
		3077	case DRM_FORMAT_ABGR2101010:
		3078	case DRM_FORMAT_RGBA1010102:
		3079	case DRM_FORMAT_BGRA1010102:
		3080	case DRM_FORMAT_YUYV:
		3081	case DRM_FORMAT_YVYU:
		3082	case DRM_FORMAT_UYVY:
		3083	case DRM_FORMAT_VYUY:
		3084	case DRM_FORMAT_AYUV:
		3085	case DRM_FORMAT_NV12:
		3086	case DRM_FORMAT_NV21:
		3087	case DRM_FORMAT_NV16:
		3088	case DRM_FORMAT_NV61:
		3089	case DRM_FORMAT_NV24:
		3090	case DRM_FORMAT_NV42:
		3091	case DRM_FORMAT_YUV410:
		3092	case DRM_FORMAT_YVU410:
		3093	case DRM_FORMAT_YUV411:
		3094	case DRM_FORMAT_YVU411:
		3095	case DRM_FORMAT_YUV420:
		3096	case DRM_FORMAT_YVU420:
		3097	case DRM_FORMAT_YUV422:
		3098	case DRM_FORMAT_YVU422:
		3099	case DRM_FORMAT_YUV444:
		3100	case DRM_FORMAT_YVU444:
		3101	return 0;
		3102	default:
4560	Serge	3103	DRM_DEBUG_KMS("invalid pixel format %s\n",
		3104	drm_get_format_name(r->pixel_format));
3031	serge	3105	return -EINVAL;
		3106	}
		3107	}
		3108
		3109	static int framebuffer_check(const struct drm_mode_fb_cmd2 *r)
		3110	{
		3111	int ret, hsub, vsub, num_planes, i;
		3112
		3113	ret = format_check(r);
		3114	if (ret) {
4075	Serge	3115	DRM_DEBUG_KMS("bad framebuffer format %s\n",
		3116	drm_get_format_name(r->pixel_format));
3031	serge	3117	return ret;
		3118	}
		3119
		3120	hsub = drm_format_horz_chroma_subsampling(r->pixel_format);
		3121	vsub = drm_format_vert_chroma_subsampling(r->pixel_format);
		3122	num_planes = drm_format_num_planes(r->pixel_format);
		3123
		3124	if (r->width == 0 \|\| r->width % hsub) {
5271	serge	3125	DRM_DEBUG_KMS("bad framebuffer width %u\n", r->width);
3031	serge	3126	return -EINVAL;
		3127	}
		3128
		3129	if (r->height == 0 \|\| r->height % vsub) {
		3130	DRM_DEBUG_KMS("bad framebuffer height %u\n", r->height);
		3131	return -EINVAL;
		3132	}
		3133
		3134	for (i = 0; i < num_planes; i++) {
		3135	unsigned int width = r->width / (i != 0 ? hsub : 1);
3192	Serge	3136	unsigned int height = r->height / (i != 0 ? vsub : 1);
		3137	unsigned int cpp = drm_format_plane_cpp(r->pixel_format, i);
3031	serge	3138
		3139	if (!r->handles[i]) {
		3140	DRM_DEBUG_KMS("no buffer object handle for plane %d\n", i);
		3141	return -EINVAL;
		3142	}
		3143
3192	Serge	3144	if ((uint64_t) width * cpp > UINT_MAX)
		3145	return -ERANGE;
		3146
		3147	if ((uint64_t) height * r->pitches[i] + r->offsets[i] > UINT_MAX)
		3148	return -ERANGE;
		3149
		3150	if (r->pitches[i] < width * cpp) {
3031	serge	3151	DRM_DEBUG_KMS("bad pitch %u for plane %d\n", r->pitches[i], i);
		3152	return -EINVAL;
		3153	}
6084	serge	3154
		3155	if (r->modifier[i] && !(r->flags & DRM_MODE_FB_MODIFIERS)) {
		3156	DRM_DEBUG_KMS("bad fb modifier %llu for plane %d\n",
		3157	r->modifier[i], i);
		3158	return -EINVAL;
		3159	}
		3160
		3161	/* modifier specific checks: */
		3162	switch (r->modifier[i]) {
		3163	case DRM_FORMAT_MOD_SAMSUNG_64_32_TILE:
		3164	/* NOTE: the pitch restriction may be lifted later if it turns
		3165	* out that no hw has this restriction:
		3166	*/
		3167	if (r->pixel_format != DRM_FORMAT_NV12 \|\|
		3168	width % 128 \|\| height % 32 \|\|
		3169	r->pitches[i] % 128) {
		3170	DRM_DEBUG_KMS("bad modifier data for plane %d\n", i);
		3171	return -EINVAL;
		3172	}
		3173	break;
		3174
		3175	default:
		3176	break;
		3177	}
3031	serge	3178	}
		3179
6084	serge	3180	for (i = num_planes; i < 4; i++) {
		3181	if (r->modifier[i]) {
		3182	DRM_DEBUG_KMS("non-zero modifier for unused plane %d\n", i);
		3183	return -EINVAL;
		3184	}
		3185
		3186	/* Pre-FB_MODIFIERS userspace didn't clear the structs properly. */
		3187	if (!(r->flags & DRM_MODE_FB_MODIFIERS))
		3188	continue;
		3189
		3190	if (r->handles[i]) {
		3191	DRM_DEBUG_KMS("buffer object handle for unused plane %d\n", i);
		3192	return -EINVAL;
		3193	}
		3194
		3195	if (r->pitches[i]) {
		3196	DRM_DEBUG_KMS("non-zero pitch for unused plane %d\n", i);
		3197	return -EINVAL;
		3198	}
		3199
		3200	if (r->offsets[i]) {
		3201	DRM_DEBUG_KMS("non-zero offset for unused plane %d\n", i);
		3202	return -EINVAL;
		3203	}
		3204	}
		3205
3031	serge	3206	return 0;
		3207	}
		3208
6084	serge	3209	static struct drm_framebuffer *
		3210	internal_framebuffer_create(struct drm_device *dev,
6937	serge	3211	const struct drm_mode_fb_cmd2 *r,
6084	serge	3212	struct drm_file *file_priv)
3031	serge	3213	{
		3214	struct drm_mode_config *config = &dev->mode_config;
		3215	struct drm_framebuffer *fb;
		3216	int ret;
		3217
6084	serge	3218	if (r->flags & ~(DRM_MODE_FB_INTERLACED \| DRM_MODE_FB_MODIFIERS)) {
3192	Serge	3219	DRM_DEBUG_KMS("bad framebuffer flags 0x%08x\n", r->flags);
5060	serge	3220	return ERR_PTR(-EINVAL);
3192	Serge	3221	}
		3222
1123	serge	3223	if ((config->min_width > r->width) \|\| (r->width > config->max_width)) {
3031	serge	3224	DRM_DEBUG_KMS("bad framebuffer width %d, should be >= %d && <= %d\n",
		3225	r->width, config->min_width, config->max_width);
5060	serge	3226	return ERR_PTR(-EINVAL);
1123	serge	3227	}
		3228	if ((config->min_height > r->height) \|\| (r->height > config->max_height)) {
3031	serge	3229	DRM_DEBUG_KMS("bad framebuffer height %d, should be >= %d && <= %d\n",
		3230	r->height, config->min_height, config->max_height);
5060	serge	3231	return ERR_PTR(-EINVAL);
1123	serge	3232	}
		3233
6084	serge	3234	if (r->flags & DRM_MODE_FB_MODIFIERS &&
		3235	!dev->mode_config.allow_fb_modifiers) {
		3236	DRM_DEBUG_KMS("driver does not support fb modifiers\n");
		3237	return ERR_PTR(-EINVAL);
		3238	}
		3239
3031	serge	3240	ret = framebuffer_check(r);
		3241	if (ret)
5060	serge	3242	return ERR_PTR(ret);
3031	serge	3243
1123	serge	3244	fb = dev->mode_config.funcs->fb_create(dev, file_priv, r);
1963	serge	3245	if (IS_ERR(fb)) {
3031	serge	3246	DRM_DEBUG_KMS("could not create framebuffer\n");
5060	serge	3247	return fb;
1123	serge	3248	}
		3249
5060	serge	3250	return fb;
		3251	}
3480	Serge	3252
5060	serge	3253	/**
		3254	* drm_mode_addfb2 - add an FB to the graphics configuration
		3255	* @dev: drm device for the ioctl
		3256	* @data: data pointer for the ioctl
		3257	* @file_priv: drm file for the ioctl call
		3258	*
		3259	* Add a new FB to the specified CRTC, given a user request with format. This is
		3260	* the 2nd version of the addfb ioctl, which supports multi-planar framebuffers
		3261	* and uses fourcc codes as pixel format specifiers.
		3262	*
		3263	* Called by the user via ioctl.
		3264	*
		3265	* Returns:
5271	serge	3266	* Zero on success, negative errno on failure.
5060	serge	3267	*/
		3268	int drm_mode_addfb2(struct drm_device *dev,
		3269	void data, struct drm_file file_priv)
		3270	{
6084	serge	3271	struct drm_mode_fb_cmd2 *r = data;
5060	serge	3272	struct drm_framebuffer *fb;
		3273
		3274	if (!drm_core_check_feature(dev, DRIVER_MODESET))
		3275	return -EINVAL;
		3276
6084	serge	3277	fb = internal_framebuffer_create(dev, r, file_priv);
5060	serge	3278	if (IS_ERR(fb))
		3279	return PTR_ERR(fb);
		3280
6084	serge	3281	/* Transfer ownership to the filp for reaping on close */
		3282
		3283	DRM_DEBUG_KMS("[FB:%d]\n", fb->base.id);
		3284	mutex_lock(&file_priv->fbs_lock);
		3285	r->fb_id = fb->base.id;
		3286	list_add(&fb->filp_head, &file_priv->fbs);
		3287	mutex_unlock(&file_priv->fbs_lock);
		3288
5060	serge	3289	return 0;
1123	serge	3290	}
		3291
		3292	/**
		3293	* drm_mode_rmfb - remove an FB from the configuration
3480	Serge	3294	* @dev: drm device for the ioctl
		3295	* @data: data pointer for the ioctl
		3296	* @file_priv: drm file for the ioctl call
1123	serge	3297	*
		3298	* Remove the FB specified by the user.
		3299	*
		3300	* Called by the user via ioctl.
		3301	*
5060	serge	3302	* Returns:
5271	serge	3303	* Zero on success, negative errno on failure.
1123	serge	3304	*/
		3305	int drm_mode_rmfb(struct drm_device *dev,
		3306	void data, struct drm_file file_priv)
		3307	{
		3308	struct drm_framebuffer *fb = NULL;
		3309	struct drm_framebuffer *fbl = NULL;
		3310	uint32_t *id = data;
		3311	int found = 0;
		3312
1963	serge	3313	if (!drm_core_check_feature(dev, DRIVER_MODESET))
		3314	return -EINVAL;
		3315
3480	Serge	3316	mutex_lock(&file_priv->fbs_lock);
		3317	mutex_lock(&dev->mode_config.fb_lock);
		3318	fb = __drm_framebuffer_lookup(dev, *id);
		3319	if (!fb)
		3320	goto fail_lookup;
1123	serge	3321
		3322	list_for_each_entry(fbl, &file_priv->fbs, filp_head)
		3323	if (fb == fbl)
		3324	found = 1;
3480	Serge	3325	if (!found)
		3326	goto fail_lookup;
1123	serge	3327
3480	Serge	3328	list_del_init(&fb->filp_head);
		3329	mutex_unlock(&dev->mode_config.fb_lock);
		3330	mutex_unlock(&file_priv->fbs_lock);
		3331
6084	serge	3332	drm_framebuffer_unreference(fb);
1123	serge	3333
3480	Serge	3334	return 0;
		3335
		3336	fail_lookup:
		3337	mutex_unlock(&dev->mode_config.fb_lock);
		3338	mutex_unlock(&file_priv->fbs_lock);
		3339
4560	Serge	3340	return -ENOENT;
1123	serge	3341	}
		3342
		3343	/**
		3344	* drm_mode_getfb - get FB info
3480	Serge	3345	* @dev: drm device for the ioctl
		3346	* @data: data pointer for the ioctl
		3347	* @file_priv: drm file for the ioctl call
1123	serge	3348	*
		3349	* Lookup the FB given its ID and return info about it.
		3350	*
		3351	* Called by the user via ioctl.
		3352	*
5060	serge	3353	* Returns:
5271	serge	3354	* Zero on success, negative errno on failure.
1123	serge	3355	*/
		3356	int drm_mode_getfb(struct drm_device *dev,
		3357	void data, struct drm_file file_priv)
		3358	{
		3359	struct drm_mode_fb_cmd *r = data;
		3360	struct drm_framebuffer *fb;
3480	Serge	3361	int ret;
1123	serge	3362
1963	serge	3363	if (!drm_core_check_feature(dev, DRIVER_MODESET))
		3364	return -EINVAL;
		3365
3480	Serge	3366	fb = drm_framebuffer_lookup(dev, r->fb_id);
		3367	if (!fb)
4560	Serge	3368	return -ENOENT;
1123	serge	3369
		3370	r->height = fb->height;
		3371	r->width = fb->width;
		3372	r->depth = fb->depth;
		3373	r->bpp = fb->bits_per_pixel;
3031	serge	3374	r->pitch = fb->pitches[0];
4104	Serge	3375	if (fb->funcs->create_handle) {
5271	serge	3376	if (file_priv->is_master \|\| capable(CAP_SYS_ADMIN) \|\|
		3377	drm_is_control_client(file_priv)) {
4104	Serge	3378	ret = fb->funcs->create_handle(fb, file_priv,
		3379	&r->handle);
		3380	} else {
		3381	/* GET_FB() is an unprivileged ioctl so we must not
		3382	* return a buffer-handle to non-master processes! For
		3383	* backwards-compatibility reasons, we cannot make
		3384	* GET_FB() privileged, so just return an invalid handle
		3385	* for non-masters. */
		3386	r->handle = 0;
		3387	ret = 0;
		3388	}
		3389	} else {
3480	Serge	3390	ret = -ENODEV;
4104	Serge	3391	}
1123	serge	3392
3480	Serge	3393	drm_framebuffer_unreference(fb);
		3394
1123	serge	3395	return ret;
		3396	}
		3397
5060	serge	3398	/**
		3399	* drm_mode_dirtyfb_ioctl - flush frontbuffer rendering on an FB
		3400	* @dev: drm device for the ioctl
		3401	* @data: data pointer for the ioctl
		3402	* @file_priv: drm file for the ioctl call
		3403	*
		3404	* Lookup the FB and flush out the damaged area supplied by userspace as a clip
		3405	* rectangle list. Generic userspace which does frontbuffer rendering must call
		3406	* this ioctl to flush out the changes on manual-update display outputs, e.g.
		3407	* usb display-link, mipi manual update panels or edp panel self refresh modes.
		3408	*
		3409	* Modesetting drivers which always update the frontbuffer do not need to
		3410	* implement the corresponding ->dirty framebuffer callback.
		3411	*
		3412	* Called by the user via ioctl.
		3413	*
		3414	* Returns:
5271	serge	3415	* Zero on success, negative errno on failure.
5060	serge	3416	*/
1412	serge	3417	int drm_mode_dirtyfb_ioctl(struct drm_device *dev,
		3418	void data, struct drm_file file_priv)
		3419	{
		3420	struct drm_clip_rect __user *clips_ptr;
		3421	struct drm_clip_rect *clips = NULL;
		3422	struct drm_mode_fb_dirty_cmd *r = data;
		3423	struct drm_framebuffer *fb;
		3424	unsigned flags;
		3425	int num_clips;
3031	serge	3426	int ret;
1412	serge	3427
1963	serge	3428	if (!drm_core_check_feature(dev, DRIVER_MODESET))
		3429	return -EINVAL;
		3430
3480	Serge	3431	fb = drm_framebuffer_lookup(dev, r->fb_id);
		3432	if (!fb)
4560	Serge	3433	return -ENOENT;
1412	serge	3434
		3435	num_clips = r->num_clips;
3031	serge	3436	clips_ptr = (struct drm_clip_rect __user *)(unsigned long)r->clips_ptr;
1412	serge	3437
		3438	if (!num_clips != !clips_ptr) {
		3439	ret = -EINVAL;
		3440	goto out_err1;
		3441	}
		3442
		3443	flags = DRM_MODE_FB_DIRTY_FLAGS & r->flags;
		3444
		3445	/* If userspace annotates copy, clips must come in pairs */
		3446	if (flags & DRM_MODE_FB_DIRTY_ANNOTATE_COPY && (num_clips % 2)) {
		3447	ret = -EINVAL;
		3448	goto out_err1;
		3449	}
		3450
		3451	if (num_clips && clips_ptr) {
3031	serge	3452	if (num_clips < 0 \|\| num_clips > DRM_MODE_FB_DIRTY_MAX_CLIPS) {
		3453	ret = -EINVAL;
		3454	goto out_err1;
		3455	}
6084	serge	3456	clips = kcalloc(num_clips, sizeof(*clips), GFP_KERNEL);
1412	serge	3457	if (!clips) {
		3458	ret = -ENOMEM;
		3459	goto out_err1;
		3460	}
		3461
		3462	ret = copy_from_user(clips, clips_ptr,
		3463	num_clips * sizeof(*clips));
1963	serge	3464	if (ret) {
		3465	ret = -EFAULT;
1412	serge	3466	goto out_err2;
6084	serge	3467	}
1412	serge	3468	}
		3469
		3470	if (fb->funcs->dirty) {
1963	serge	3471	ret = fb->funcs->dirty(fb, file_priv, flags, r->color,
		3472	clips, num_clips);
1412	serge	3473	} else {
		3474	ret = -ENOSYS;
		3475	}
		3476
		3477	out_err2:
		3478	kfree(clips);
		3479	out_err1:
3480	Serge	3480	drm_framebuffer_unreference(fb);
		3481
1412	serge	3482	return ret;
		3483	}
		3484
6937	serge	3485
1123	serge	3486	/**
		3487	* drm_fb_release - remove and free the FBs on this file
3480	Serge	3488	* @priv: drm file for the ioctl
1123	serge	3489	*
		3490	* Destroy all the FBs associated with @filp.
		3491	*
		3492	* Called by the user via ioctl.
		3493	*
5060	serge	3494	* Returns:
5271	serge	3495	* Zero on success, negative errno on failure.
1123	serge	3496	*/
		3497	void drm_fb_release(struct drm_file *priv)
		3498	{
		3499	struct drm_framebuffer fb, tfb;
		3500
5271	serge	3501	/*
		3502	* When the file gets released that means no one else can access the fb
		3503	* list any more, so no need to grab fpriv->fbs_lock. And we need to
		3504	* avoid upsetting lockdep since the universal cursor code adds a
		3505	* framebuffer while holding mutex locks.
		3506	*
		3507	* Note that a real deadlock between fpriv->fbs_lock and the modeset
		3508	* locks is impossible here since no one else but this function can get
		3509	* at it any more.
		3510	*/
1123	serge	3511	list_for_each_entry_safe(fb, tfb, &priv->fbs, filp_head) {
3480	Serge	3512	list_del_init(&fb->filp_head);
		3513
6084	serge	3514	/* This drops the fpriv->fbs reference. */
		3515	drm_framebuffer_unreference(fb);
1123	serge	3516	}
		3517	}
		3518	#endif
		3519
		3520
5060	serge	3521	/**
		3522	* drm_property_create - create a new property type
		3523	* @dev: drm device
		3524	* @flags: flags specifying the property type
		3525	* @name: name of the property
		3526	* @num_values: number of pre-defined values
		3527	*
		3528	* This creates a new generic drm property which can then be attached to a drm
		3529	* object with drm_object_attach_property. The returned property object must be
		3530	* freed with drm_property_destroy.
		3531	*
5271	serge	3532	* Note that the DRM core keeps a per-device list of properties and that, if
		3533	* drm_mode_config_cleanup() is called, it will destroy all properties created
		3534	* by the driver.
		3535	*
5060	serge	3536	* Returns:
		3537	* A pointer to the newly created property on success, NULL on failure.
		3538	*/
1123	serge	3539	struct drm_property drm_property_create(struct drm_device dev, int flags,
		3540	const char *name, int num_values)
		3541	{
		3542	struct drm_property *property = NULL;
3031	serge	3543	int ret;
1123	serge	3544
		3545	property = kzalloc(sizeof(struct drm_property), GFP_KERNEL);
		3546	if (!property)
		3547	return NULL;
		3548
5060	serge	3549	property->dev = dev;
		3550
1123	serge	3551	if (num_values) {
6084	serge	3552	property->values = kcalloc(num_values, sizeof(uint64_t),
		3553	GFP_KERNEL);
1123	serge	3554	if (!property->values)
		3555	goto fail;
		3556	}
		3557
3031	serge	3558	ret = drm_mode_object_get(dev, &property->base, DRM_MODE_OBJECT_PROPERTY);
		3559	if (ret)
		3560	goto fail;
		3561
1123	serge	3562	property->flags = flags;
		3563	property->num_values = num_values;
5271	serge	3564	INIT_LIST_HEAD(&property->enum_list);
1123	serge	3565
3031	serge	3566	if (name) {
1123	serge	3567	strncpy(property->name, name, DRM_PROP_NAME_LEN);
3031	serge	3568	property->name[DRM_PROP_NAME_LEN-1] = '\0';
		3569	}
1123	serge	3570
		3571	list_add_tail(&property->head, &dev->mode_config.property_list);
5060	serge	3572
		3573	WARN_ON(!drm_property_type_valid(property));
		3574
1123	serge	3575	return property;
		3576	fail:
3031	serge	3577	kfree(property->values);
1123	serge	3578	kfree(property);
		3579	return NULL;
		3580	}
		3581	EXPORT_SYMBOL(drm_property_create);
		3582
5060	serge	3583	/**
		3584	* drm_property_create_enum - create a new enumeration property type
		3585	* @dev: drm device
		3586	* @flags: flags specifying the property type
		3587	* @name: name of the property
		3588	* @props: enumeration lists with property values
		3589	* @num_values: number of pre-defined values
		3590	*
		3591	* This creates a new generic drm property which can then be attached to a drm
		3592	* object with drm_object_attach_property. The returned property object must be
		3593	* freed with drm_property_destroy.
		3594	*
		3595	* Userspace is only allowed to set one of the predefined values for enumeration
		3596	* properties.
		3597	*
		3598	* Returns:
		3599	* A pointer to the newly created property on success, NULL on failure.
		3600	*/
3031	serge	3601	struct drm_property drm_property_create_enum(struct drm_device dev, int flags,
		3602	const char *name,
		3603	const struct drm_prop_enum_list *props,
		3604	int num_values)
		3605	{
		3606	struct drm_property *property;
		3607	int i, ret;
		3608
		3609	flags \|= DRM_MODE_PROP_ENUM;
		3610
		3611	property = drm_property_create(dev, flags, name, num_values);
		3612	if (!property)
		3613	return NULL;
		3614
		3615	for (i = 0; i < num_values; i++) {
		3616	ret = drm_property_add_enum(property, i,
		3617	props[i].type,
		3618	props[i].name);
		3619	if (ret) {
		3620	drm_property_destroy(dev, property);
		3621	return NULL;
		3622	}
		3623	}
		3624
		3625	return property;
		3626	}
		3627	EXPORT_SYMBOL(drm_property_create_enum);
		3628
5060	serge	3629	/**
		3630	* drm_property_create_bitmask - create a new bitmask property type
		3631	* @dev: drm device
		3632	* @flags: flags specifying the property type
		3633	* @name: name of the property
		3634	* @props: enumeration lists with property bitflags
5271	serge	3635	* @num_props: size of the @props array
		3636	* @supported_bits: bitmask of all supported enumeration values
5060	serge	3637	*
5271	serge	3638	* This creates a new bitmask drm property which can then be attached to a drm
5060	serge	3639	* object with drm_object_attach_property. The returned property object must be
		3640	* freed with drm_property_destroy.
		3641	*
		3642	* Compared to plain enumeration properties userspace is allowed to set any
		3643	* or'ed together combination of the predefined property bitflag values
		3644	*
		3645	* Returns:
		3646	* A pointer to the newly created property on success, NULL on failure.
		3647	*/
3031	serge	3648	struct drm_property drm_property_create_bitmask(struct drm_device dev,
		3649	int flags, const char *name,
		3650	const struct drm_prop_enum_list *props,
5060	serge	3651	int num_props,
		3652	uint64_t supported_bits)
3031	serge	3653	{
		3654	struct drm_property *property;
5060	serge	3655	int i, ret, index = 0;
		3656	int num_values = hweight64(supported_bits);
3031	serge	3657
		3658	flags \|= DRM_MODE_PROP_BITMASK;
		3659
		3660	property = drm_property_create(dev, flags, name, num_values);
		3661	if (!property)
		3662	return NULL;
5060	serge	3663	for (i = 0; i < num_props; i++) {
		3664	if (!(supported_bits & (1ULL << props[i].type)))
		3665	continue;
3031	serge	3666
5060	serge	3667	if (WARN_ON(index >= num_values)) {
		3668	drm_property_destroy(dev, property);
		3669	return NULL;
		3670	}
		3671
		3672	ret = drm_property_add_enum(property, index++,
3031	serge	3673	props[i].type,
		3674	props[i].name);
		3675	if (ret) {
		3676	drm_property_destroy(dev, property);
		3677	return NULL;
		3678	}
		3679	}
		3680
		3681	return property;
		3682	}
		3683	EXPORT_SYMBOL(drm_property_create_bitmask);
		3684
5060	serge	3685	static struct drm_property property_create_range(struct drm_device dev,
		3686	int flags, const char *name,
3031	serge	3687	uint64_t min, uint64_t max)
		3688	{
		3689	struct drm_property *property;
		3690
		3691	property = drm_property_create(dev, flags, name, 2);
		3692	if (!property)
		3693	return NULL;
		3694
		3695	property->values[0] = min;
		3696	property->values[1] = max;
		3697
		3698	return property;
		3699	}
5060	serge	3700
		3701	/**
6084	serge	3702	* drm_property_create_range - create a new unsigned ranged property type
5060	serge	3703	* @dev: drm device
		3704	* @flags: flags specifying the property type
		3705	* @name: name of the property
		3706	* @min: minimum value of the property
		3707	* @max: maximum value of the property
		3708	*
		3709	* This creates a new generic drm property which can then be attached to a drm
		3710	* object with drm_object_attach_property. The returned property object must be
		3711	* freed with drm_property_destroy.
		3712	*
6084	serge	3713	* Userspace is allowed to set any unsigned integer value in the (min, max)
		3714	* range inclusive.
5060	serge	3715	*
		3716	* Returns:
		3717	* A pointer to the newly created property on success, NULL on failure.
		3718	*/
		3719	struct drm_property drm_property_create_range(struct drm_device dev, int flags,
		3720	const char *name,
		3721	uint64_t min, uint64_t max)
		3722	{
		3723	return property_create_range(dev, DRM_MODE_PROP_RANGE \| flags,
		3724	name, min, max);
		3725	}
3031	serge	3726	EXPORT_SYMBOL(drm_property_create_range);
		3727
6084	serge	3728	/**
		3729	* drm_property_create_signed_range - create a new signed ranged property type
		3730	* @dev: drm device
		3731	* @flags: flags specifying the property type
		3732	* @name: name of the property
		3733	* @min: minimum value of the property
		3734	* @max: maximum value of the property
		3735	*
		3736	* This creates a new generic drm property which can then be attached to a drm
		3737	* object with drm_object_attach_property. The returned property object must be
		3738	* freed with drm_property_destroy.
		3739	*
		3740	* Userspace is allowed to set any signed integer value in the (min, max)
		3741	* range inclusive.
		3742	*
		3743	* Returns:
		3744	* A pointer to the newly created property on success, NULL on failure.
		3745	*/
5060	serge	3746	struct drm_property drm_property_create_signed_range(struct drm_device dev,
		3747	int flags, const char *name,
		3748	int64_t min, int64_t max)
		3749	{
		3750	return property_create_range(dev, DRM_MODE_PROP_SIGNED_RANGE \| flags,
		3751	name, I642U64(min), I642U64(max));
		3752	}
		3753	EXPORT_SYMBOL(drm_property_create_signed_range);
		3754
6084	serge	3755	/**
		3756	* drm_property_create_object - create a new object property type
		3757	* @dev: drm device
		3758	* @flags: flags specifying the property type
		3759	* @name: name of the property
		3760	* @type: object type from DRM_MODE_OBJECT_* defines
		3761	*
		3762	* This creates a new generic drm property which can then be attached to a drm
		3763	* object with drm_object_attach_property. The returned property object must be
		3764	* freed with drm_property_destroy.
		3765	*
		3766	* Userspace is only allowed to set this to any property value of the given
		3767	* @type. Only useful for atomic properties, which is enforced.
		3768	*
		3769	* Returns:
		3770	* A pointer to the newly created property on success, NULL on failure.
		3771	*/
5060	serge	3772	struct drm_property drm_property_create_object(struct drm_device dev,
		3773	int flags, const char *name, uint32_t type)
		3774	{
		3775	struct drm_property *property;
		3776
		3777	flags \|= DRM_MODE_PROP_OBJECT;
		3778
6084	serge	3779	if (WARN_ON(!(flags & DRM_MODE_PROP_ATOMIC)))
		3780	return NULL;
		3781
5060	serge	3782	property = drm_property_create(dev, flags, name, 1);
		3783	if (!property)
		3784	return NULL;
		3785
		3786	property->values[0] = type;
		3787
		3788	return property;
		3789	}
		3790	EXPORT_SYMBOL(drm_property_create_object);
		3791
		3792	/**
6084	serge	3793	* drm_property_create_bool - create a new boolean property type
		3794	* @dev: drm device
		3795	* @flags: flags specifying the property type
		3796	* @name: name of the property
		3797	*
		3798	* This creates a new generic drm property which can then be attached to a drm
		3799	* object with drm_object_attach_property. The returned property object must be
		3800	* freed with drm_property_destroy.
		3801	*
		3802	* This is implemented as a ranged property with only {0, 1} as valid values.
		3803	*
		3804	* Returns:
		3805	* A pointer to the newly created property on success, NULL on failure.
		3806	*/
		3807	struct drm_property drm_property_create_bool(struct drm_device dev, int flags,
		3808	const char *name)
		3809	{
		3810	return drm_property_create_range(dev, flags, name, 0, 1);
		3811	}
		3812	EXPORT_SYMBOL(drm_property_create_bool);
		3813
		3814	/**
5060	serge	3815	* drm_property_add_enum - add a possible value to an enumeration property
		3816	* @property: enumeration property to change
		3817	* @index: index of the new enumeration
		3818	* @value: value of the new enumeration
		3819	* @name: symbolic name of the new enumeration
		3820	*
		3821	* This functions adds enumerations to a property.
		3822	*
		3823	* It's use is deprecated, drivers should use one of the more specific helpers
		3824	* to directly create the property with all enumerations already attached.
		3825	*
		3826	* Returns:
		3827	* Zero on success, error code on failure.
		3828	*/
1123	serge	3829	int drm_property_add_enum(struct drm_property *property, int index,
		3830	uint64_t value, const char *name)
		3831	{
		3832	struct drm_property_enum *prop_enum;
		3833
5060	serge	3834	if (!(drm_property_type_is(property, DRM_MODE_PROP_ENUM) \|\|
		3835	drm_property_type_is(property, DRM_MODE_PROP_BITMASK)))
1123	serge	3836	return -EINVAL;
		3837
3031	serge	3838	/*
		3839	* Bitmask enum properties have the additional constraint of values
		3840	* from 0 to 63
		3841	*/
5060	serge	3842	if (drm_property_type_is(property, DRM_MODE_PROP_BITMASK) &&
		3843	(value > 63))
3031	serge	3844	return -EINVAL;
		3845
5271	serge	3846	if (!list_empty(&property->enum_list)) {
		3847	list_for_each_entry(prop_enum, &property->enum_list, head) {
1123	serge	3848	if (prop_enum->value == value) {
		3849	strncpy(prop_enum->name, name, DRM_PROP_NAME_LEN);
		3850	prop_enum->name[DRM_PROP_NAME_LEN-1] = '\0';
		3851	return 0;
		3852	}
		3853	}
		3854	}
		3855
		3856	prop_enum = kzalloc(sizeof(struct drm_property_enum), GFP_KERNEL);
		3857	if (!prop_enum)
		3858	return -ENOMEM;
		3859
		3860	strncpy(prop_enum->name, name, DRM_PROP_NAME_LEN);
		3861	prop_enum->name[DRM_PROP_NAME_LEN-1] = '\0';
		3862	prop_enum->value = value;
		3863
		3864	property->values[index] = value;
5271	serge	3865	list_add_tail(&prop_enum->head, &property->enum_list);
1123	serge	3866	return 0;
		3867	}
		3868	EXPORT_SYMBOL(drm_property_add_enum);
		3869
5060	serge	3870	/**
		3871	* drm_property_destroy - destroy a drm property
		3872	* @dev: drm device
		3873	* @property: property to destry
		3874	*
		3875	* This function frees a property including any attached resources like
		3876	* enumeration values.
		3877	*/
1123	serge	3878	void drm_property_destroy(struct drm_device dev, struct drm_property property)
		3879	{
		3880	struct drm_property_enum prop_enum, pt;
		3881
5271	serge	3882	list_for_each_entry_safe(prop_enum, pt, &property->enum_list, head) {
1123	serge	3883	list_del(&prop_enum->head);
		3884	kfree(prop_enum);
		3885	}
		3886
		3887	if (property->num_values)
		3888	kfree(property->values);
		3889	drm_mode_object_put(dev, &property->base);
		3890	list_del(&property->head);
		3891	kfree(property);
		3892	}
		3893	EXPORT_SYMBOL(drm_property_destroy);
		3894
5060	serge	3895	/**
		3896	* drm_object_attach_property - attach a property to a modeset object
		3897	* @obj: drm modeset object
		3898	* @property: property to attach
		3899	* @init_val: initial value of the property
		3900	*
		3901	* This attaches the given property to the modeset object with the given initial
		3902	* value. Currently this function cannot fail since the properties are stored in
		3903	* a statically sized array.
		3904	*/
3031	serge	3905	void drm_object_attach_property(struct drm_mode_object *obj,
		3906	struct drm_property *property,
		3907	uint64_t init_val)
		3908	{
		3909	int count = obj->properties->count;
		3910
		3911	if (count == DRM_OBJECT_MAX_PROPERTY) {
		3912	WARN(1, "Failed to attach object property (type: 0x%x). Please "
		3913	"increase DRM_OBJECT_MAX_PROPERTY by 1 for each time "
		3914	"you see this message on the same object type.\n",
		3915	obj->type);
		3916	return;
		3917	}
		3918
6084	serge	3919	obj->properties->properties[count] = property;
3031	serge	3920	obj->properties->values[count] = init_val;
		3921	obj->properties->count++;
6084	serge	3922	if (property->flags & DRM_MODE_PROP_ATOMIC)
		3923	obj->properties->atomic_count++;
3031	serge	3924	}
		3925	EXPORT_SYMBOL(drm_object_attach_property);
		3926
5060	serge	3927	/**
		3928	* drm_object_property_set_value - set the value of a property
		3929	* @obj: drm mode object to set property value for
		3930	* @property: property to set
		3931	* @val: value the property should be set to
		3932	*
		3933	* This functions sets a given property on a given object. This function only
		3934	* changes the software state of the property, it does not call into the
		3935	* driver's ->set_property callback.
		3936	*
		3937	* Returns:
		3938	* Zero on success, error code on failure.
		3939	*/
3031	serge	3940	int drm_object_property_set_value(struct drm_mode_object *obj,
		3941	struct drm_property *property, uint64_t val)
		3942	{
1123	serge	3943	int i;
		3944
3031	serge	3945	for (i = 0; i < obj->properties->count; i++) {
6084	serge	3946	if (obj->properties->properties[i] == property) {
3031	serge	3947	obj->properties->values[i] = val;
		3948	return 0;
1123	serge	3949	}
		3950	}
		3951
6084	serge	3952	return -EINVAL;
1123	serge	3953	}
3031	serge	3954	EXPORT_SYMBOL(drm_object_property_set_value);
1123	serge	3955
5060	serge	3956	/**
		3957	* drm_object_property_get_value - retrieve the value of a property
		3958	* @obj: drm mode object to get property value from
		3959	* @property: property to retrieve
		3960	* @val: storage for the property value
		3961	*
		3962	* This function retrieves the softare state of the given property for the given
		3963	* property. Since there is no driver callback to retrieve the current property
		3964	* value this might be out of sync with the hardware, depending upon the driver
		3965	* and property.
		3966	*
		3967	* Returns:
		3968	* Zero on success, error code on failure.
		3969	*/
3031	serge	3970	int drm_object_property_get_value(struct drm_mode_object *obj,
1123	serge	3971	struct drm_property property, uint64_t val)
		3972	{
		3973	int i;
		3974
6084	serge	3975	/* read-only properties bypass atomic mechanism and still store
		3976	* their value in obj->properties->values[].. mostly to avoid
		3977	* having to deal w/ EDID and similar props in atomic paths:
		3978	*/
		3979	if (drm_core_check_feature(property->dev, DRIVER_ATOMIC) &&
		3980	!(property->flags & DRM_MODE_PROP_IMMUTABLE))
		3981	return drm_atomic_get_property(obj, property, val);
		3982
3031	serge	3983	for (i = 0; i < obj->properties->count; i++) {
6084	serge	3984	if (obj->properties->properties[i] == property) {
3031	serge	3985	*val = obj->properties->values[i];
		3986	return 0;
1123	serge	3987	}
		3988	}
		3989
6084	serge	3990	return -EINVAL;
1123	serge	3991	}
3031	serge	3992	EXPORT_SYMBOL(drm_object_property_get_value);
1123	serge	3993
		3994	#if 0
5060	serge	3995	/**
5271	serge	3996	* drm_mode_getproperty_ioctl - get the property metadata
5060	serge	3997	* @dev: DRM device
		3998	* @data: ioctl data
		3999	* @file_priv: DRM file info
		4000	*
5271	serge	4001	* This function retrieves the metadata for a given property, like the different
		4002	* possible values for an enum property or the limits for a range property.
5060	serge	4003	*
5271	serge	4004	* Blob properties are special
		4005	*
5060	serge	4006	* Called by the user via ioctl.
		4007	*
		4008	* Returns:
5271	serge	4009	* Zero on success, negative errno on failure.
5060	serge	4010	*/
1123	serge	4011	int drm_mode_getproperty_ioctl(struct drm_device *dev,
		4012	void data, struct drm_file file_priv)
		4013	{
		4014	struct drm_mode_get_property *out_resp = data;
		4015	struct drm_property *property;
		4016	int enum_count = 0;
		4017	int value_count = 0;
		4018	int ret = 0, i;
		4019	int copied;
		4020	struct drm_property_enum *prop_enum;
		4021	struct drm_mode_property_enum __user *enum_ptr;
		4022	uint64_t __user *values_ptr;
		4023
1963	serge	4024	if (!drm_core_check_feature(dev, DRIVER_MODESET))
		4025	return -EINVAL;
		4026
3480	Serge	4027	drm_modeset_lock_all(dev);
5060	serge	4028	property = drm_property_find(dev, out_resp->prop_id);
		4029	if (!property) {
4560	Serge	4030	ret = -ENOENT;
1123	serge	4031	goto done;
		4032	}
		4033
5060	serge	4034	if (drm_property_type_is(property, DRM_MODE_PROP_ENUM) \|\|
		4035	drm_property_type_is(property, DRM_MODE_PROP_BITMASK)) {
5271	serge	4036	list_for_each_entry(prop_enum, &property->enum_list, head)
1123	serge	4037	enum_count++;
		4038	}
		4039
		4040	value_count = property->num_values;
		4041
		4042	strncpy(out_resp->name, property->name, DRM_PROP_NAME_LEN);
		4043	out_resp->name[DRM_PROP_NAME_LEN-1] = 0;
		4044	out_resp->flags = property->flags;
		4045
		4046	if ((out_resp->count_values >= value_count) && value_count) {
3031	serge	4047	values_ptr = (uint64_t __user *)(unsigned long)out_resp->values_ptr;
1123	serge	4048	for (i = 0; i < value_count; i++) {
		4049	if (copy_to_user(values_ptr + i, &property->values[i], sizeof(uint64_t))) {
		4050	ret = -EFAULT;
		4051	goto done;
		4052	}
		4053	}
		4054	}
		4055	out_resp->count_values = value_count;
		4056
5060	serge	4057	if (drm_property_type_is(property, DRM_MODE_PROP_ENUM) \|\|
		4058	drm_property_type_is(property, DRM_MODE_PROP_BITMASK)) {
1123	serge	4059	if ((out_resp->count_enum_blobs >= enum_count) && enum_count) {
		4060	copied = 0;
3031	serge	4061	enum_ptr = (struct drm_mode_property_enum __user *)(unsigned long)out_resp->enum_blob_ptr;
5271	serge	4062	list_for_each_entry(prop_enum, &property->enum_list, head) {
1123	serge	4063
		4064	if (copy_to_user(&enum_ptr[copied].value, &prop_enum->value, sizeof(uint64_t))) {
		4065	ret = -EFAULT;
		4066	goto done;
		4067	}
		4068
		4069	if (copy_to_user(&enum_ptr[copied].name,
		4070	&prop_enum->name, DRM_PROP_NAME_LEN)) {
		4071	ret = -EFAULT;
		4072	goto done;
		4073	}
		4074	copied++;
		4075	}
		4076	}
		4077	out_resp->count_enum_blobs = enum_count;
		4078	}
		4079
5271	serge	4080	/*
		4081	* NOTE: The idea seems to have been to use this to read all the blob
		4082	* property values. But nothing ever added them to the corresponding
		4083	* list, userspace always used the special-purpose get_blob ioctl to
		4084	* read the value for a blob property. It also doesn't make a lot of
		4085	* sense to return values here when everything else is just metadata for
		4086	* the property itself.
		4087	*/
		4088	if (drm_property_type_is(property, DRM_MODE_PROP_BLOB))
		4089	out_resp->count_enum_blobs = 0;
1123	serge	4090	done:
3480	Serge	4091	drm_modeset_unlock_all(dev);
1123	serge	4092	return ret;
		4093	}
		4094	#endif
		4095
6084	serge	4096	/**
		4097	* drm_property_create_blob - Create new blob property
		4098	*
		4099	* Creates a new blob property for a specified DRM device, optionally
		4100	* copying data.
		4101	*
		4102	* @dev: DRM device to create property for
		4103	* @length: Length to allocate for blob data
		4104	* @data: If specified, copies data into blob
		4105	*
		4106	* Returns:
		4107	* New blob property with a single reference on success, or an ERR_PTR
		4108	* value on failure.
		4109	*/
		4110	struct drm_property_blob *
5271	serge	4111	drm_property_create_blob(struct drm_device *dev, size_t length,
		4112	const void *data)
1123	serge	4113	{
		4114	struct drm_property_blob *blob;
3031	serge	4115	int ret;
1123	serge	4116
6084	serge	4117	if (!length \|\| length > ULONG_MAX - sizeof(struct drm_property_blob))
		4118	return ERR_PTR(-EINVAL);
1123	serge	4119
		4120	blob = kzalloc(sizeof(struct drm_property_blob)+length, GFP_KERNEL);
		4121	if (!blob)
6084	serge	4122	return ERR_PTR(-ENOMEM);
1123	serge	4123
6084	serge	4124	/* This must be explicitly initialised, so we can safely call list_del
		4125	* on it in the removal handler, even if it isn't in a file list. */
		4126	INIT_LIST_HEAD(&blob->head_file);
		4127	blob->length = length;
		4128	blob->dev = dev;
		4129
		4130	if (data)
		4131	memcpy(blob->data, data, length);
		4132
		4133	mutex_lock(&dev->mode_config.blob_lock);
		4134
3031	serge	4135	ret = drm_mode_object_get(dev, &blob->base, DRM_MODE_OBJECT_BLOB);
		4136	if (ret) {
		4137	kfree(blob);
6084	serge	4138	mutex_unlock(&dev->mode_config.blob_lock);
		4139	return ERR_PTR(-EINVAL);
3031	serge	4140	}
		4141
6084	serge	4142	kref_init(&blob->refcount);
1123	serge	4143
6084	serge	4144	list_add_tail(&blob->head_global,
		4145	&dev->mode_config.property_blob_list);
1123	serge	4146
6084	serge	4147	mutex_unlock(&dev->mode_config.blob_lock);
		4148
1123	serge	4149	return blob;
		4150	}
6084	serge	4151	EXPORT_SYMBOL(drm_property_create_blob);
1123	serge	4152
6084	serge	4153	/**
		4154	* drm_property_free_blob - Blob property destructor
		4155	*
		4156	* Internal free function for blob properties; must not be used directly.
		4157	*
		4158	* @kref: Reference
		4159	*/
		4160	static void drm_property_free_blob(struct kref *kref)
1123	serge	4161	{
6084	serge	4162	struct drm_property_blob *blob =
		4163	container_of(kref, struct drm_property_blob, refcount);
		4164
		4165	WARN_ON(!mutex_is_locked(&blob->dev->mode_config.blob_lock));
		4166
		4167	list_del(&blob->head_global);
		4168	list_del(&blob->head_file);
		4169	drm_mode_object_put(blob->dev, &blob->base);
		4170
1123	serge	4171	kfree(blob);
		4172	}
		4173
6084	serge	4174	/**
		4175	* drm_property_unreference_blob - Unreference a blob property
		4176	*
		4177	* Drop a reference on a blob property. May free the object.
		4178	*
		4179	* @blob: Pointer to blob property
		4180	*/
		4181	void drm_property_unreference_blob(struct drm_property_blob *blob)
		4182	{
		4183	struct drm_device *dev;
		4184
		4185	if (!blob)
		4186	return;
		4187
		4188	dev = blob->dev;
		4189
		4190	DRM_DEBUG("%p: blob ID: %d (%d)\n", blob, blob->base.id, atomic_read(&blob->refcount.refcount));
		4191
		4192	if (kref_put_mutex(&blob->refcount, drm_property_free_blob,
		4193	&dev->mode_config.blob_lock))
		4194	mutex_unlock(&dev->mode_config.blob_lock);
		4195	else
		4196	might_lock(&dev->mode_config.blob_lock);
		4197	}
		4198	EXPORT_SYMBOL(drm_property_unreference_blob);
		4199
		4200	/**
		4201	* drm_property_unreference_blob_locked - Unreference a blob property with blob_lock held
		4202	*
		4203	* Drop a reference on a blob property. May free the object. This must be
		4204	* called with blob_lock held.
		4205	*
		4206	* @blob: Pointer to blob property
		4207	*/
		4208	static void drm_property_unreference_blob_locked(struct drm_property_blob *blob)
		4209	{
		4210	if (!blob)
		4211	return;
		4212
		4213	DRM_DEBUG("%p: blob ID: %d (%d)\n", blob, blob->base.id, atomic_read(&blob->refcount.refcount));
		4214
		4215	kref_put(&blob->refcount, drm_property_free_blob);
		4216	}
		4217
		4218	/**
		4219	* drm_property_destroy_user_blobs - destroy all blobs created by this client
		4220	* @dev: DRM device
		4221	* @file_priv: destroy all blobs owned by this file handle
		4222	*/
		4223	void drm_property_destroy_user_blobs(struct drm_device *dev,
		4224	struct drm_file *file_priv)
		4225	{
		4226	struct drm_property_blob blob, bt;
		4227
		4228	mutex_lock(&dev->mode_config.blob_lock);
		4229
		4230	list_for_each_entry_safe(blob, bt, &file_priv->blobs, head_file) {
		4231	list_del_init(&blob->head_file);
		4232	drm_property_unreference_blob_locked(blob);
		4233	}
		4234
		4235	mutex_unlock(&dev->mode_config.blob_lock);
		4236	}
		4237
		4238	/**
		4239	* drm_property_reference_blob - Take a reference on an existing property
		4240	*
		4241	* Take a new reference on an existing blob property.
		4242	*
		4243	* @blob: Pointer to blob property
		4244	*/
		4245	struct drm_property_blob drm_property_reference_blob(struct drm_property_blob blob)
		4246	{
		4247	DRM_DEBUG("%p: blob ID: %d (%d)\n", blob, blob->base.id, atomic_read(&blob->refcount.refcount));
		4248	kref_get(&blob->refcount);
		4249	return blob;
		4250	}
		4251	EXPORT_SYMBOL(drm_property_reference_blob);
		4252
		4253	/*
		4254	* Like drm_property_lookup_blob, but does not return an additional reference.
		4255	* Must be called with blob_lock held.
		4256	*/
		4257	static struct drm_property_blob __drm_property_lookup_blob(struct drm_device dev,
		4258	uint32_t id)
		4259	{
		4260	struct drm_mode_object *obj = NULL;
		4261	struct drm_property_blob *blob;
		4262
		4263	WARN_ON(!mutex_is_locked(&dev->mode_config.blob_lock));
		4264
		4265	mutex_lock(&dev->mode_config.idr_mutex);
		4266	obj = idr_find(&dev->mode_config.crtc_idr, id);
		4267	if (!obj \|\| (obj->type != DRM_MODE_OBJECT_BLOB) \|\| (obj->id != id))
		4268	blob = NULL;
		4269	else
		4270	blob = obj_to_blob(obj);
		4271	mutex_unlock(&dev->mode_config.idr_mutex);
		4272
		4273	return blob;
		4274	}
		4275
		4276	/**
		4277	* drm_property_lookup_blob - look up a blob property and take a reference
		4278	* @dev: drm device
		4279	* @id: id of the blob property
		4280	*
		4281	* If successful, this takes an additional reference to the blob property.
		4282	* callers need to make sure to eventually unreference the returned property
		4283	* again, using @drm_property_unreference_blob.
		4284	*/
		4285	struct drm_property_blob drm_property_lookup_blob(struct drm_device dev,
		4286	uint32_t id)
		4287	{
		4288	struct drm_property_blob *blob;
		4289
		4290	mutex_lock(&dev->mode_config.blob_lock);
		4291	blob = __drm_property_lookup_blob(dev, id);
		4292	if (blob) {
		4293	if (!kref_get_unless_zero(&blob->refcount))
		4294	blob = NULL;
		4295	}
		4296	mutex_unlock(&dev->mode_config.blob_lock);
		4297
		4298	return blob;
		4299	}
		4300	EXPORT_SYMBOL(drm_property_lookup_blob);
		4301
		4302	/**
		4303	* drm_property_replace_global_blob - atomically replace existing blob property
		4304	* @dev: drm device
		4305	* @replace: location of blob property pointer to be replaced
		4306	* @length: length of data for new blob, or 0 for no data
		4307	* @data: content for new blob, or NULL for no data
		4308	* @obj_holds_id: optional object for property holding blob ID
		4309	* @prop_holds_id: optional property holding blob ID
		4310	* @return 0 on success or error on failure
		4311	*
		4312	* This function will atomically replace a global property in the blob list,
		4313	* optionally updating a property which holds the ID of that property. It is
		4314	* guaranteed to be atomic: no caller will be allowed to see intermediate
		4315	* results, and either the entire operation will succeed and clean up the
		4316	* previous property, or it will fail and the state will be unchanged.
		4317	*
		4318	* If length is 0 or data is NULL, no new blob will be created, and the holding
		4319	* property, if specified, will be set to 0.
		4320	*
		4321	* Access to the replace pointer is assumed to be protected by the caller, e.g.
		4322	* by holding the relevant modesetting object lock for its parent.
		4323	*
		4324	* For example, a drm_connector has a 'PATH' property, which contains the ID
		4325	* of a blob property with the value of the MST path information. Calling this
		4326	* function with replace pointing to the connector's path_blob_ptr, length and
		4327	* data set for the new path information, obj_holds_id set to the connector's
		4328	* base object, and prop_holds_id set to the path property name, will perform
		4329	* a completely atomic update. The access to path_blob_ptr is protected by the
		4330	* caller holding a lock on the connector.
		4331	*/
		4332	static int drm_property_replace_global_blob(struct drm_device *dev,
		4333	struct drm_property_blob **replace,
		4334	size_t length,
		4335	const void *data,
		4336	struct drm_mode_object *obj_holds_id,
		4337	struct drm_property *prop_holds_id)
		4338	{
		4339	struct drm_property_blob *new_blob = NULL;
		4340	struct drm_property_blob *old_blob = NULL;
		4341	int ret;
		4342
		4343	WARN_ON(replace == NULL);
		4344
		4345	old_blob = *replace;
		4346
		4347	if (length && data) {
		4348	new_blob = drm_property_create_blob(dev, length, data);
		4349	if (IS_ERR(new_blob))
		4350	return PTR_ERR(new_blob);
		4351	}
		4352
		4353	/* This does not need to be synchronised with blob_lock, as the
		4354	* get_properties ioctl locks all modesetting objects, and
		4355	* obj_holds_id must be locked before calling here, so we cannot
		4356	* have its value out of sync with the list membership modified
		4357	* below under blob_lock. */
		4358	if (obj_holds_id) {
		4359	ret = drm_object_property_set_value(obj_holds_id,
		4360	prop_holds_id,
		4361	new_blob ?
		4362	new_blob->base.id : 0);
		4363	if (ret != 0)
		4364	goto err_created;
		4365	}
		4366
		4367	drm_property_unreference_blob(old_blob);
		4368	*replace = new_blob;
		4369
		4370	return 0;
		4371
		4372	err_created:
		4373	drm_property_unreference_blob(new_blob);
		4374	return ret;
		4375	}
		4376
		4377
1123	serge	4378	#if 0
5060	serge	4379	/**
		4380	* drm_mode_getblob_ioctl - get the contents of a blob property value
		4381	* @dev: DRM device
		4382	* @data: ioctl data
		4383	* @file_priv: DRM file info
		4384	*
		4385	* This function retrieves the contents of a blob property. The value stored in
		4386	* an object's blob property is just a normal modeset object id.
		4387	*
		4388	* Called by the user via ioctl.
		4389	*
		4390	* Returns:
5271	serge	4391	* Zero on success, negative errno on failure.
5060	serge	4392	*/
1123	serge	4393	int drm_mode_getblob_ioctl(struct drm_device *dev,
		4394	void data, struct drm_file file_priv)
		4395	{
		4396	struct drm_mode_get_blob *out_resp = data;
		4397	struct drm_property_blob *blob;
		4398	int ret = 0;
3031	serge	4399	void __user *blob_ptr;
1123	serge	4400
1963	serge	4401	if (!drm_core_check_feature(dev, DRIVER_MODESET))
		4402	return -EINVAL;
		4403
3480	Serge	4404	drm_modeset_lock_all(dev);
6084	serge	4405	mutex_lock(&dev->mode_config.blob_lock);
		4406	blob = __drm_property_lookup_blob(dev, out_resp->blob_id);
5060	serge	4407	if (!blob) {
4560	Serge	4408	ret = -ENOENT;
1123	serge	4409	goto done;
		4410	}
		4411
		4412	if (out_resp->length == blob->length) {
3031	serge	4413	blob_ptr = (void __user *)(unsigned long)out_resp->data;
6084	serge	4414	if (copy_to_user(blob_ptr, blob->data, blob->length)) {
1123	serge	4415	ret = -EFAULT;
		4416	goto done;
		4417	}
		4418	}
		4419	out_resp->length = blob->length;
		4420
		4421	done:
6084	serge	4422	mutex_unlock(&dev->mode_config.blob_lock);
3480	Serge	4423	drm_modeset_unlock_all(dev);
1123	serge	4424	return ret;
		4425	}
		4426	#endif
		4427
5271	serge	4428	/**
		4429	* drm_mode_connector_set_path_property - set tile property on connector
		4430	* @connector: connector to set property on.
6084	serge	4431	* @path: path to use for property; must not be NULL.
5271	serge	4432	*
		4433	* This creates a property to expose to userspace to specify a
		4434	* connector path. This is mainly used for DisplayPort MST where
		4435	* connectors have a topology and we want to allow userspace to give
		4436	* them more meaningful names.
		4437	*
		4438	* Returns:
		4439	* Zero on success, negative errno on failure.
		4440	*/
5060	serge	4441	int drm_mode_connector_set_path_property(struct drm_connector *connector,
5271	serge	4442	const char *path)
5060	serge	4443	{
		4444	struct drm_device *dev = connector->dev;
5271	serge	4445	int ret;
5060	serge	4446
6084	serge	4447	ret = drm_property_replace_global_blob(dev,
		4448	&connector->path_blob_ptr,
		4449	strlen(path) + 1,
		4450	path,
		4451	&connector->base,
		4452	dev->mode_config.path_property);
5060	serge	4453	return ret;
		4454	}
		4455	EXPORT_SYMBOL(drm_mode_connector_set_path_property);
		4456
		4457	/**
5271	serge	4458	* drm_mode_connector_set_tile_property - set tile property on connector
		4459	* @connector: connector to set property on.
		4460	*
		4461	* This looks up the tile information for a connector, and creates a
		4462	* property for userspace to parse if it exists. The property is of
		4463	* the form of 8 integers using ':' as a separator.
		4464	*
		4465	* Returns:
		4466	* Zero on success, errno on failure.
		4467	*/
		4468	int drm_mode_connector_set_tile_property(struct drm_connector *connector)
		4469	{
		4470	struct drm_device *dev = connector->dev;
		4471	char tile[256];
6084	serge	4472	int ret;
5271	serge	4473
		4474	if (!connector->has_tile) {
6084	serge	4475	ret = drm_property_replace_global_blob(dev,
		4476	&connector->tile_blob_ptr,
		4477	0,
		4478	NULL,
		4479	&connector->base,
		4480	dev->mode_config.tile_property);
5271	serge	4481	return ret;
		4482	}
		4483
		4484	snprintf(tile, 256, "%d:%d:%d:%d:%d:%d:%d:%d",
		4485	connector->tile_group->id, connector->tile_is_single_monitor,
		4486	connector->num_h_tile, connector->num_v_tile,
		4487	connector->tile_h_loc, connector->tile_v_loc,
		4488	connector->tile_h_size, connector->tile_v_size);
		4489
6084	serge	4490	ret = drm_property_replace_global_blob(dev,
		4491	&connector->tile_blob_ptr,
		4492	strlen(tile) + 1,
		4493	tile,
		4494	&connector->base,
		4495	dev->mode_config.tile_property);
5271	serge	4496	return ret;
		4497	}
		4498	EXPORT_SYMBOL(drm_mode_connector_set_tile_property);
		4499
		4500	/**
5060	serge	4501	* drm_mode_connector_update_edid_property - update the edid property of a connector
		4502	* @connector: drm connector
		4503	* @edid: new value of the edid property
		4504	*
		4505	* This function creates a new blob modeset object and assigns its id to the
		4506	* connector's edid property.
		4507	*
		4508	* Returns:
5367	serge	4509	* Zero on success, negative errno on failure.
5060	serge	4510	*/
1123	serge	4511	int drm_mode_connector_update_edid_property(struct drm_connector *connector,
5271	serge	4512	const struct edid *edid)
1123	serge	4513	{
		4514	struct drm_device *dev = connector->dev;
6084	serge	4515	size_t size = 0;
5271	serge	4516	int ret;
1123	serge	4517
5060	serge	4518	/* ignore requests to set edid when overridden */
		4519	if (connector->override_edid)
		4520	return 0;
		4521
6084	serge	4522	if (edid)
		4523	size = EDID_LENGTH * (1 + edid->extensions);
1123	serge	4524
6084	serge	4525	ret = drm_property_replace_global_blob(dev,
		4526	&connector->edid_blob_ptr,
		4527	size,
		4528	edid,
		4529	&connector->base,
		4530	dev->mode_config.edid_property);
		4531	return ret;
		4532	}
		4533	EXPORT_SYMBOL(drm_mode_connector_update_edid_property);
		4534
		4535	/* Some properties could refer to dynamic refcnt'd objects, or things that
		4536	* need special locking to handle lifetime issues (ie. to ensure the prop
		4537	* value doesn't become invalid part way through the property update due to
		4538	* race). The value returned by reference via 'obj' should be passed back
		4539	* to drm_property_change_valid_put() after the property is set (and the
		4540	* object to which the property is attached has a chance to take it's own
		4541	* reference).
		4542	*/
		4543	bool drm_property_change_valid_get(struct drm_property *property,
		4544	uint64_t value, struct drm_mode_object **ref)
		4545	{
		4546	int i;
		4547
		4548	if (property->flags & DRM_MODE_PROP_IMMUTABLE)
		4549	return false;
		4550
		4551	*ref = NULL;
		4552
		4553	if (drm_property_type_is(property, DRM_MODE_PROP_RANGE)) {
		4554	if (value < property->values[0] \|\| value > property->values[1])
		4555	return false;
		4556	return true;
		4557	} else if (drm_property_type_is(property, DRM_MODE_PROP_SIGNED_RANGE)) {
		4558	int64_t svalue = U642I64(value);
		4559
		4560	if (svalue < U642I64(property->values[0]) \|\|
		4561	svalue > U642I64(property->values[1]))
		4562	return false;
		4563	return true;
		4564	} else if (drm_property_type_is(property, DRM_MODE_PROP_BITMASK)) {
		4565	uint64_t valid_mask = 0;
		4566
		4567	for (i = 0; i < property->num_values; i++)
		4568	valid_mask \|= (1ULL << property->values[i]);
		4569	return !(value & ~valid_mask);
		4570	} else if (drm_property_type_is(property, DRM_MODE_PROP_BLOB)) {
		4571	struct drm_property_blob *blob;
		4572
		4573	if (value == 0)
		4574	return true;
		4575
		4576	blob = drm_property_lookup_blob(property->dev, value);
		4577	if (blob) {
		4578	*ref = &blob->base;
		4579	return true;
		4580	} else {
		4581	return false;
		4582	}
		4583	} else if (drm_property_type_is(property, DRM_MODE_PROP_OBJECT)) {
		4584	/* a zero value for an object property translates to null: */
		4585	if (value == 0)
		4586	return true;
		4587
		4588	/* handle refcnt'd objects specially: */
		4589	if (property->values[0] == DRM_MODE_OBJECT_FB) {
		4590	struct drm_framebuffer *fb;
		4591	fb = drm_framebuffer_lookup(property->dev, value);
		4592	if (fb) {
		4593	*ref = &fb->base;
		4594	return true;
		4595	} else {
		4596	return false;
		4597	}
		4598	} else {
		4599	return _object_find(property->dev, value, property->values[0]) != NULL;
		4600	}
1123	serge	4601	}
		4602
6084	serge	4603	for (i = 0; i < property->num_values; i++)
		4604	if (property->values[i] == value)
		4605	return true;
		4606	return false;
		4607	}
1123	serge	4608
6084	serge	4609	void drm_property_change_valid_put(struct drm_property *property,
		4610	struct drm_mode_object *ref)
		4611	{
		4612	if (!ref)
		4613	return;
1123	serge	4614
6084	serge	4615	if (drm_property_type_is(property, DRM_MODE_PROP_OBJECT)) {
		4616	if (property->values[0] == DRM_MODE_OBJECT_FB)
		4617	drm_framebuffer_unreference(obj_to_fb(ref));
		4618	} else if (drm_property_type_is(property, DRM_MODE_PROP_BLOB))
		4619	drm_property_unreference_blob(obj_to_blob(ref));
1123	serge	4620	}
		4621
3031	serge	4622
5271	serge	4623
3031	serge	4624	static int drm_mode_connector_set_obj_prop(struct drm_mode_object *obj,
		4625	struct drm_property *property,
		4626	uint64_t value)
1123	serge	4627	{
3031	serge	4628	int ret = -EINVAL;
		4629	struct drm_connector *connector = obj_to_connector(obj);
		4630
		4631	/* Do DPMS ourselves */
		4632	if (property == connector->dev->mode_config.dpms_property) {
6084	serge	4633	ret = (*connector->funcs->dpms)(connector, (int)value);
3031	serge	4634	} else if (connector->funcs->set_property)
		4635	ret = connector->funcs->set_property(connector, property, value);
		4636
		4637	/* store the property value if successful */
		4638	if (!ret)
3192	Serge	4639	drm_object_property_set_value(&connector->base, property, value);
3031	serge	4640	return ret;
		4641	}
		4642
		4643	static int drm_mode_crtc_set_obj_prop(struct drm_mode_object *obj,
		4644	struct drm_property *property,
		4645	uint64_t value)
		4646	{
		4647	int ret = -EINVAL;
		4648	struct drm_crtc *crtc = obj_to_crtc(obj);
		4649
		4650	if (crtc->funcs->set_property)
		4651	ret = crtc->funcs->set_property(crtc, property, value);
		4652	if (!ret)
		4653	drm_object_property_set_value(obj, property, value);
		4654
		4655	return ret;
		4656	}
		4657
5271	serge	4658	/**
		4659	* drm_mode_plane_set_obj_prop - set the value of a property
		4660	* @plane: drm plane object to set property value for
		4661	* @property: property to set
		4662	* @value: value the property should be set to
		4663	*
		4664	* This functions sets a given property on a given plane object. This function
		4665	* calls the driver's ->set_property callback and changes the software state of
		4666	* the property if the callback succeeds.
		4667	*
		4668	* Returns:
		4669	* Zero on success, error code on failure.
		4670	*/
		4671	int drm_mode_plane_set_obj_prop(struct drm_plane *plane,
6084	serge	4672	struct drm_property *property,
		4673	uint64_t value)
3031	serge	4674	{
		4675	int ret = -EINVAL;
5271	serge	4676	struct drm_mode_object *obj = &plane->base;
3031	serge	4677
		4678	if (plane->funcs->set_property)
		4679	ret = plane->funcs->set_property(plane, property, value);
		4680	if (!ret)
		4681	drm_object_property_set_value(obj, property, value);
		4682
		4683	return ret;
		4684	}
5271	serge	4685	EXPORT_SYMBOL(drm_mode_plane_set_obj_prop);
3031	serge	4686
5271	serge	4687	#if 0
5060	serge	4688	/**
5271	serge	4689	* drm_mode_obj_get_properties_ioctl - get the current value of a object's property
5060	serge	4690	* @dev: DRM device
		4691	* @data: ioctl data
		4692	* @file_priv: DRM file info
		4693	*
		4694	* This function retrieves the current value for an object's property. Compared
		4695	* to the connector specific ioctl this one is extended to also work on crtc and
		4696	* plane objects.
		4697	*
		4698	* Called by the user via ioctl.
		4699	*
		4700	* Returns:
5271	serge	4701	* Zero on success, negative errno on failure.
5060	serge	4702	*/
3031	serge	4703	int drm_mode_obj_get_properties_ioctl(struct drm_device dev, void data,
		4704	struct drm_file *file_priv)
		4705	{
		4706	struct drm_mode_obj_get_properties *arg = data;
1123	serge	4707	struct drm_mode_object *obj;
3031	serge	4708	int ret = 0;
1123	serge	4709
1963	serge	4710	if (!drm_core_check_feature(dev, DRIVER_MODESET))
		4711	return -EINVAL;
		4712
3480	Serge	4713	drm_modeset_lock_all(dev);
1123	serge	4714
3031	serge	4715	obj = drm_mode_object_find(dev, arg->obj_id, arg->obj_type);
1123	serge	4716	if (!obj) {
4560	Serge	4717	ret = -ENOENT;
1123	serge	4718	goto out;
		4719	}
3031	serge	4720	if (!obj->properties) {
		4721	ret = -EINVAL;
		4722	goto out;
		4723	}
1123	serge	4724
6084	serge	4725	ret = get_properties(obj, file_priv->atomic,
		4726	(uint32_t __user *)(unsigned long)(arg->props_ptr),
		4727	(uint64_t __user *)(unsigned long)(arg->prop_values_ptr),
		4728	&arg->count_props);
3031	serge	4729
		4730	out:
3480	Serge	4731	drm_modeset_unlock_all(dev);
3031	serge	4732	return ret;
		4733	}
1123	serge	4734
5060	serge	4735	/**
		4736	* drm_mode_obj_set_property_ioctl - set the current value of an object's property
		4737	* @dev: DRM device
		4738	* @data: ioctl data
		4739	* @file_priv: DRM file info
		4740	*
		4741	* This function sets the current value for an object's property. It also calls
		4742	* into a driver's ->set_property callback to update the hardware state.
		4743	* Compared to the connector specific ioctl this one is extended to also work on
		4744	* crtc and plane objects.
		4745	*
		4746	* Called by the user via ioctl.
		4747	*
		4748	* Returns:
5271	serge	4749	* Zero on success, negative errno on failure.
5060	serge	4750	*/
3031	serge	4751	int drm_mode_obj_set_property_ioctl(struct drm_device dev, void data,
		4752	struct drm_file *file_priv)
		4753	{
		4754	struct drm_mode_obj_set_property *arg = data;
		4755	struct drm_mode_object *arg_obj;
		4756	struct drm_mode_object *prop_obj;
		4757	struct drm_property *property;
6084	serge	4758	int i, ret = -EINVAL;
		4759	struct drm_mode_object *ref;
3031	serge	4760
		4761	if (!drm_core_check_feature(dev, DRIVER_MODESET))
		4762	return -EINVAL;
		4763
3480	Serge	4764	drm_modeset_lock_all(dev);
3031	serge	4765
		4766	arg_obj = drm_mode_object_find(dev, arg->obj_id, arg->obj_type);
4560	Serge	4767	if (!arg_obj) {
		4768	ret = -ENOENT;
1123	serge	4769	goto out;
4560	Serge	4770	}
3031	serge	4771	if (!arg_obj->properties)
		4772	goto out;
1123	serge	4773
3031	serge	4774	for (i = 0; i < arg_obj->properties->count; i++)
6084	serge	4775	if (arg_obj->properties->properties[i]->base.id == arg->prop_id)
3031	serge	4776	break;
		4777
		4778	if (i == arg_obj->properties->count)
1123	serge	4779	goto out;
		4780
3031	serge	4781	prop_obj = drm_mode_object_find(dev, arg->prop_id,
		4782	DRM_MODE_OBJECT_PROPERTY);
4560	Serge	4783	if (!prop_obj) {
		4784	ret = -ENOENT;
6084	serge	4785	goto out;
4560	Serge	4786	}
3031	serge	4787	property = obj_to_property(prop_obj);
1123	serge	4788
6084	serge	4789	if (!drm_property_change_valid_get(property, arg->value, &ref))
		4790	goto out;
3031	serge	4791
		4792	switch (arg_obj->type) {
		4793	case DRM_MODE_OBJECT_CONNECTOR:
		4794	ret = drm_mode_connector_set_obj_prop(arg_obj, property,
		4795	arg->value);
		4796	break;
		4797	case DRM_MODE_OBJECT_CRTC:
		4798	ret = drm_mode_crtc_set_obj_prop(arg_obj, property, arg->value);
		4799	break;
		4800	case DRM_MODE_OBJECT_PLANE:
5271	serge	4801	ret = drm_mode_plane_set_obj_prop(obj_to_plane(arg_obj),
		4802	property, arg->value);
6084	serge	4803	break;
		4804	}
1123	serge	4805
6084	serge	4806	drm_property_change_valid_put(property, ref);
		4807
1123	serge	4808	out:
3480	Serge	4809	drm_modeset_unlock_all(dev);
1123	serge	4810	return ret;
		4811	}
		4812	#endif
		4813
5060	serge	4814	/**
		4815	* drm_mode_connector_attach_encoder - attach a connector to an encoder
		4816	* @connector: connector to attach
		4817	* @encoder: encoder to attach @connector to
		4818	*
		4819	* This function links up a connector to an encoder. Note that the routing
		4820	* restrictions between encoders and crtcs are exposed to userspace through the
		4821	* possible_clones and possible_crtcs bitmasks.
		4822	*
		4823	* Returns:
5271	serge	4824	* Zero on success, negative errno on failure.
5060	serge	4825	*/
1123	serge	4826	int drm_mode_connector_attach_encoder(struct drm_connector *connector,
		4827	struct drm_encoder *encoder)
		4828	{
		4829	int i;
		4830
6937	serge	4831	/*
		4832	* In the past, drivers have attempted to model the static association
		4833	* of connector to encoder in simple connector/encoder devices using a
		4834	* direct assignment of connector->encoder = encoder. This connection
		4835	* is a logical one and the responsibility of the core, so drivers are
		4836	* expected not to mess with this.
		4837	*
		4838	* Note that the error return should've been enough here, but a large
		4839	* majority of drivers ignores the return value, so add in a big WARN
		4840	* to get people's attention.
		4841	*/
		4842	if (WARN_ON(connector->encoder))
		4843	return -EINVAL;
		4844
1123	serge	4845	for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
		4846	if (connector->encoder_ids[i] == 0) {
		4847	connector->encoder_ids[i] = encoder->base.id;
		4848	return 0;
		4849	}
		4850	}
		4851	return -ENOMEM;
		4852	}
		4853	EXPORT_SYMBOL(drm_mode_connector_attach_encoder);
		4854
5060	serge	4855	/**
		4856	* drm_mode_crtc_set_gamma_size - set the gamma table size
		4857	* @crtc: CRTC to set the gamma table size for
		4858	* @gamma_size: size of the gamma table
		4859	*
		4860	* Drivers which support gamma tables should set this to the supported gamma
		4861	* table size when initializing the CRTC. Currently the drm core only supports a
		4862	* fixed gamma table size.
		4863	*
		4864	* Returns:
5271	serge	4865	* Zero on success, negative errno on failure.
5060	serge	4866	*/
3031	serge	4867	int drm_mode_crtc_set_gamma_size(struct drm_crtc *crtc,
6084	serge	4868	int gamma_size)
1123	serge	4869	{
		4870	crtc->gamma_size = gamma_size;
		4871
6084	serge	4872	crtc->gamma_store = kcalloc(gamma_size, sizeof(uint16_t) * 3,
		4873	GFP_KERNEL);
1123	serge	4874	if (!crtc->gamma_store) {
		4875	crtc->gamma_size = 0;
3031	serge	4876	return -ENOMEM;
1123	serge	4877	}
		4878
3031	serge	4879	return 0;
1123	serge	4880	}
		4881	EXPORT_SYMBOL(drm_mode_crtc_set_gamma_size);
		4882
		4883	#if 0
5060	serge	4884	/**
		4885	* drm_mode_gamma_set_ioctl - set the gamma table
		4886	* @dev: DRM device
		4887	* @data: ioctl data
		4888	* @file_priv: DRM file info
		4889	*
		4890	* Set the gamma table of a CRTC to the one passed in by the user. Userspace can
		4891	* inquire the required gamma table size through drm_mode_gamma_get_ioctl.
		4892	*
		4893	* Called by the user via ioctl.
		4894	*
		4895	* Returns:
5271	serge	4896	* Zero on success, negative errno on failure.
5060	serge	4897	*/
1123	serge	4898	int drm_mode_gamma_set_ioctl(struct drm_device *dev,
		4899	void data, struct drm_file file_priv)
		4900	{
		4901	struct drm_mode_crtc_lut *crtc_lut = data;
		4902	struct drm_crtc *crtc;
		4903	void r_base, g_base, *b_base;
		4904	int size;
		4905	int ret = 0;
		4906
1963	serge	4907	if (!drm_core_check_feature(dev, DRIVER_MODESET))
		4908	return -EINVAL;
		4909
3480	Serge	4910	drm_modeset_lock_all(dev);
5060	serge	4911	crtc = drm_crtc_find(dev, crtc_lut->crtc_id);
		4912	if (!crtc) {
4560	Serge	4913	ret = -ENOENT;
1123	serge	4914	goto out;
		4915	}
		4916
3031	serge	4917	if (crtc->funcs->gamma_set == NULL) {
		4918	ret = -ENOSYS;
		4919	goto out;
		4920	}
		4921
1123	serge	4922	/* memcpy into gamma store */
		4923	if (crtc_lut->gamma_size != crtc->gamma_size) {
		4924	ret = -EINVAL;
		4925	goto out;
		4926	}
		4927
		4928	size = crtc_lut->gamma_size * (sizeof(uint16_t));
		4929	r_base = crtc->gamma_store;
		4930	if (copy_from_user(r_base, (void __user *)(unsigned long)crtc_lut->red, size)) {
		4931	ret = -EFAULT;
		4932	goto out;
		4933	}
		4934
		4935	g_base = r_base + size;
		4936	if (copy_from_user(g_base, (void __user *)(unsigned long)crtc_lut->green, size)) {
		4937	ret = -EFAULT;
		4938	goto out;
		4939	}
		4940
		4941	b_base = g_base + size;
		4942	if (copy_from_user(b_base, (void __user *)(unsigned long)crtc_lut->blue, size)) {
		4943	ret = -EFAULT;
		4944	goto out;
		4945	}
		4946
1963	serge	4947	crtc->funcs->gamma_set(crtc, r_base, g_base, b_base, 0, crtc->gamma_size);
1123	serge	4948
		4949	out:
3480	Serge	4950	drm_modeset_unlock_all(dev);
1123	serge	4951	return ret;
		4952
		4953	}
		4954
5060	serge	4955	/**
		4956	* drm_mode_gamma_get_ioctl - get the gamma table
		4957	* @dev: DRM device
		4958	* @data: ioctl data
		4959	* @file_priv: DRM file info
		4960	*
		4961	* Copy the current gamma table into the storage provided. This also provides
		4962	* the gamma table size the driver expects, which can be used to size the
		4963	* allocated storage.
		4964	*
		4965	* Called by the user via ioctl.
		4966	*
		4967	* Returns:
5271	serge	4968	* Zero on success, negative errno on failure.
5060	serge	4969	*/
1123	serge	4970	int drm_mode_gamma_get_ioctl(struct drm_device *dev,
		4971	void data, struct drm_file file_priv)
		4972	{
		4973	struct drm_mode_crtc_lut *crtc_lut = data;
		4974	struct drm_crtc *crtc;
		4975	void r_base, g_base, *b_base;
		4976	int size;
		4977	int ret = 0;
		4978
1963	serge	4979	if (!drm_core_check_feature(dev, DRIVER_MODESET))
		4980	return -EINVAL;
		4981
3480	Serge	4982	drm_modeset_lock_all(dev);
5060	serge	4983	crtc = drm_crtc_find(dev, crtc_lut->crtc_id);
		4984	if (!crtc) {
4560	Serge	4985	ret = -ENOENT;
1123	serge	4986	goto out;
		4987	}
		4988
		4989	/* memcpy into gamma store */
		4990	if (crtc_lut->gamma_size != crtc->gamma_size) {
		4991	ret = -EINVAL;
		4992	goto out;
		4993	}
		4994
		4995	size = crtc_lut->gamma_size * (sizeof(uint16_t));
		4996	r_base = crtc->gamma_store;
		4997	if (copy_to_user((void __user *)(unsigned long)crtc_lut->red, r_base, size)) {
		4998	ret = -EFAULT;
		4999	goto out;
		5000	}
		5001
		5002	g_base = r_base + size;
		5003	if (copy_to_user((void __user *)(unsigned long)crtc_lut->green, g_base, size)) {
		5004	ret = -EFAULT;
		5005	goto out;
		5006	}
		5007
		5008	b_base = g_base + size;
		5009	if (copy_to_user((void __user *)(unsigned long)crtc_lut->blue, b_base, size)) {
		5010	ret = -EFAULT;
		5011	goto out;
		5012	}
		5013	out:
3480	Serge	5014	drm_modeset_unlock_all(dev);
1123	serge	5015	return ret;
		5016	}
		5017
		5018	#endif
1179	serge	5019
		5020
5060	serge	5021	/**
		5022	* drm_mode_config_reset - call ->reset callbacks
		5023	* @dev: drm device
		5024	*
		5025	* This functions calls all the crtc's, encoder's and connector's ->reset
		5026	* callback. Drivers can use this in e.g. their driver load or resume code to
		5027	* reset hardware and software state.
		5028	*/
1963	serge	5029	void drm_mode_config_reset(struct drm_device *dev)
		5030	{
		5031	struct drm_crtc *crtc;
5271	serge	5032	struct drm_plane *plane;
1963	serge	5033	struct drm_encoder *encoder;
		5034	struct drm_connector *connector;
		5035
6084	serge	5036	drm_for_each_plane(plane, dev)
5271	serge	5037	if (plane->funcs->reset)
		5038	plane->funcs->reset(plane);
		5039
6084	serge	5040	drm_for_each_crtc(crtc, dev)
1963	serge	5041	if (crtc->funcs->reset)
		5042	crtc->funcs->reset(crtc);
		5043
6084	serge	5044	drm_for_each_encoder(encoder, dev)
1963	serge	5045	if (encoder->funcs->reset)
		5046	encoder->funcs->reset(encoder);
		5047
6084	serge	5048	mutex_lock(&dev->mode_config.mutex);
		5049	drm_for_each_connector(connector, dev)
1963	serge	5050	if (connector->funcs->reset)
		5051	connector->funcs->reset(connector);
6084	serge	5052	mutex_unlock(&dev->mode_config.mutex);
1963	serge	5053	}
		5054	EXPORT_SYMBOL(drm_mode_config_reset);
3031	serge	5055	/*
		5056	* Just need to support RGB formats here for compat with code that doesn't
		5057	* use pixel formats directly yet.
		5058	*/
		5059	void drm_fb_get_bpp_depth(uint32_t format, unsigned int *depth,
		5060	int *bpp)
		5061	{
		5062	switch (format) {
3480	Serge	5063	case DRM_FORMAT_C8:
3031	serge	5064	case DRM_FORMAT_RGB332:
		5065	case DRM_FORMAT_BGR233:
		5066	*depth = 8;
		5067	*bpp = 8;
		5068	break;
		5069	case DRM_FORMAT_XRGB1555:
		5070	case DRM_FORMAT_XBGR1555:
		5071	case DRM_FORMAT_RGBX5551:
		5072	case DRM_FORMAT_BGRX5551:
		5073	case DRM_FORMAT_ARGB1555:
		5074	case DRM_FORMAT_ABGR1555:
		5075	case DRM_FORMAT_RGBA5551:
		5076	case DRM_FORMAT_BGRA5551:
		5077	*depth = 15;
		5078	*bpp = 16;
		5079	break;
		5080	case DRM_FORMAT_RGB565:
		5081	case DRM_FORMAT_BGR565:
		5082	*depth = 16;
		5083	*bpp = 16;
		5084	break;
		5085	case DRM_FORMAT_RGB888:
		5086	case DRM_FORMAT_BGR888:
		5087	*depth = 24;
		5088	*bpp = 24;
		5089	break;
		5090	case DRM_FORMAT_XRGB8888:
		5091	case DRM_FORMAT_XBGR8888:
		5092	case DRM_FORMAT_RGBX8888:
		5093	case DRM_FORMAT_BGRX8888:
		5094	*depth = 24;
		5095	*bpp = 32;
		5096	break;
		5097	case DRM_FORMAT_XRGB2101010:
		5098	case DRM_FORMAT_XBGR2101010:
		5099	case DRM_FORMAT_RGBX1010102:
		5100	case DRM_FORMAT_BGRX1010102:
		5101	case DRM_FORMAT_ARGB2101010:
		5102	case DRM_FORMAT_ABGR2101010:
		5103	case DRM_FORMAT_RGBA1010102:
		5104	case DRM_FORMAT_BGRA1010102:
		5105	*depth = 30;
		5106	*bpp = 32;
		5107	break;
		5108	case DRM_FORMAT_ARGB8888:
		5109	case DRM_FORMAT_ABGR8888:
		5110	case DRM_FORMAT_RGBA8888:
		5111	case DRM_FORMAT_BGRA8888:
		5112	*depth = 32;
		5113	*bpp = 32;
		5114	break;
		5115	default:
4560	Serge	5116	DRM_DEBUG_KMS("unsupported pixel format %s\n",
		5117	drm_get_format_name(format));
3031	serge	5118	*depth = 0;
		5119	*bpp = 0;
		5120	break;
		5121	}
		5122	}
		5123	EXPORT_SYMBOL(drm_fb_get_bpp_depth);
		5124
		5125	/**
		5126	* drm_format_num_planes - get the number of planes for format
		5127	* @format: pixel format (DRM_FORMAT_*)
		5128	*
5060	serge	5129	* Returns:
3031	serge	5130	* The number of planes used by the specified pixel format.
		5131	*/
		5132	int drm_format_num_planes(uint32_t format)
		5133	{
		5134	switch (format) {
		5135	case DRM_FORMAT_YUV410:
		5136	case DRM_FORMAT_YVU410:
		5137	case DRM_FORMAT_YUV411:
		5138	case DRM_FORMAT_YVU411:
		5139	case DRM_FORMAT_YUV420:
		5140	case DRM_FORMAT_YVU420:
		5141	case DRM_FORMAT_YUV422:
		5142	case DRM_FORMAT_YVU422:
		5143	case DRM_FORMAT_YUV444:
		5144	case DRM_FORMAT_YVU444:
		5145	return 3;
		5146	case DRM_FORMAT_NV12:
		5147	case DRM_FORMAT_NV21:
		5148	case DRM_FORMAT_NV16:
		5149	case DRM_FORMAT_NV61:
		5150	case DRM_FORMAT_NV24:
		5151	case DRM_FORMAT_NV42:
		5152	return 2;
		5153	default:
		5154	return 1;
		5155	}
		5156	}
		5157	EXPORT_SYMBOL(drm_format_num_planes);
		5158
		5159	/**
		5160	* drm_format_plane_cpp - determine the bytes per pixel value
		5161	* @format: pixel format (DRM_FORMAT_*)
		5162	* @plane: plane index
		5163	*
5060	serge	5164	* Returns:
3031	serge	5165	* The bytes per pixel value for the specified plane.
		5166	*/
		5167	int drm_format_plane_cpp(uint32_t format, int plane)
		5168	{
		5169	unsigned int depth;
		5170	int bpp;
		5171
		5172	if (plane >= drm_format_num_planes(format))
		5173	return 0;
		5174
		5175	switch (format) {
		5176	case DRM_FORMAT_YUYV:
		5177	case DRM_FORMAT_YVYU:
		5178	case DRM_FORMAT_UYVY:
		5179	case DRM_FORMAT_VYUY:
		5180	return 2;
		5181	case DRM_FORMAT_NV12:
		5182	case DRM_FORMAT_NV21:
		5183	case DRM_FORMAT_NV16:
		5184	case DRM_FORMAT_NV61:
		5185	case DRM_FORMAT_NV24:
		5186	case DRM_FORMAT_NV42:
		5187	return plane ? 2 : 1;
		5188	case DRM_FORMAT_YUV410:
		5189	case DRM_FORMAT_YVU410:
		5190	case DRM_FORMAT_YUV411:
		5191	case DRM_FORMAT_YVU411:
		5192	case DRM_FORMAT_YUV420:
		5193	case DRM_FORMAT_YVU420:
		5194	case DRM_FORMAT_YUV422:
		5195	case DRM_FORMAT_YVU422:
		5196	case DRM_FORMAT_YUV444:
		5197	case DRM_FORMAT_YVU444:
		5198	return 1;
		5199	default:
		5200	drm_fb_get_bpp_depth(format, &depth, &bpp);
		5201	return bpp >> 3;
		5202	}
		5203	}
		5204	EXPORT_SYMBOL(drm_format_plane_cpp);
		5205
		5206	/**
		5207	* drm_format_horz_chroma_subsampling - get the horizontal chroma subsampling factor
		5208	* @format: pixel format (DRM_FORMAT_*)
		5209	*
5060	serge	5210	* Returns:
3031	serge	5211	* The horizontal chroma subsampling factor for the
		5212	* specified pixel format.
		5213	*/
		5214	int drm_format_horz_chroma_subsampling(uint32_t format)
		5215	{
		5216	switch (format) {
		5217	case DRM_FORMAT_YUV411:
		5218	case DRM_FORMAT_YVU411:
		5219	case DRM_FORMAT_YUV410:
		5220	case DRM_FORMAT_YVU410:
		5221	return 4;
		5222	case DRM_FORMAT_YUYV:
		5223	case DRM_FORMAT_YVYU:
		5224	case DRM_FORMAT_UYVY:
		5225	case DRM_FORMAT_VYUY:
		5226	case DRM_FORMAT_NV12:
		5227	case DRM_FORMAT_NV21:
		5228	case DRM_FORMAT_NV16:
		5229	case DRM_FORMAT_NV61:
		5230	case DRM_FORMAT_YUV422:
		5231	case DRM_FORMAT_YVU422:
		5232	case DRM_FORMAT_YUV420:
		5233	case DRM_FORMAT_YVU420:
		5234	return 2;
		5235	default:
		5236	return 1;
		5237	}
		5238	}
		5239	EXPORT_SYMBOL(drm_format_horz_chroma_subsampling);
		5240
		5241	/**
		5242	* drm_format_vert_chroma_subsampling - get the vertical chroma subsampling factor
		5243	* @format: pixel format (DRM_FORMAT_*)
		5244	*
5060	serge	5245	* Returns:
3031	serge	5246	* The vertical chroma subsampling factor for the
		5247	* specified pixel format.
		5248	*/
		5249	int drm_format_vert_chroma_subsampling(uint32_t format)
		5250	{
		5251	switch (format) {
		5252	case DRM_FORMAT_YUV410:
		5253	case DRM_FORMAT_YVU410:
		5254	return 4;
		5255	case DRM_FORMAT_YUV420:
		5256	case DRM_FORMAT_YVU420:
		5257	case DRM_FORMAT_NV12:
		5258	case DRM_FORMAT_NV21:
		5259	return 2;
		5260	default:
		5261	return 1;
		5262	}
		5263	}
		5264	EXPORT_SYMBOL(drm_format_vert_chroma_subsampling);
3746	Serge	5265
		5266	/**
5271	serge	5267	* drm_rotation_simplify() - Try to simplify the rotation
		5268	* @rotation: Rotation to be simplified
		5269	* @supported_rotations: Supported rotations
		5270	*
		5271	* Attempt to simplify the rotation to a form that is supported.
		5272	* Eg. if the hardware supports everything except DRM_REFLECT_X
		5273	* one could call this function like this:
		5274	*
		5275	* drm_rotation_simplify(rotation, BIT(DRM_ROTATE_0) \|
		5276	* BIT(DRM_ROTATE_90) \| BIT(DRM_ROTATE_180) \|
		5277	* BIT(DRM_ROTATE_270) \| BIT(DRM_REFLECT_Y));
		5278	*
		5279	* to eliminate the DRM_ROTATE_X flag. Depending on what kind of
		5280	* transforms the hardware supports, this function may not
		5281	* be able to produce a supported transform, so the caller should
		5282	* check the result afterwards.
		5283	*/
		5284	unsigned int drm_rotation_simplify(unsigned int rotation,
		5285	unsigned int supported_rotations)
		5286	{
		5287	if (rotation & ~supported_rotations) {
		5288	rotation ^= BIT(DRM_REFLECT_X) \| BIT(DRM_REFLECT_Y);
6084	serge	5289	rotation = (rotation & DRM_REFLECT_MASK) \|
		5290	BIT((ffs(rotation & DRM_ROTATE_MASK) + 1) % 4);
5271	serge	5291	}
		5292
		5293	return rotation;
		5294	}
		5295	EXPORT_SYMBOL(drm_rotation_simplify);
		5296
		5297	/**
3746	Serge	5298	* drm_mode_config_init - initialize DRM mode_configuration structure
		5299	* @dev: DRM device
		5300	*
		5301	* Initialize @dev's mode_config structure, used for tracking the graphics
		5302	* configuration of @dev.
		5303	*
		5304	* Since this initializes the modeset locks, no locking is possible. Which is no
		5305	* problem, since this should happen single threaded at init time. It is the
		5306	* driver's problem to ensure this guarantee.
		5307	*
		5308	*/
		5309	void drm_mode_config_init(struct drm_device *dev)
		5310	{
		5311	mutex_init(&dev->mode_config.mutex);
5060	serge	5312	drm_modeset_lock_init(&dev->mode_config.connection_mutex);
3746	Serge	5313	mutex_init(&dev->mode_config.idr_mutex);
		5314	mutex_init(&dev->mode_config.fb_lock);
6084	serge	5315	mutex_init(&dev->mode_config.blob_lock);
3746	Serge	5316	INIT_LIST_HEAD(&dev->mode_config.fb_list);
		5317	INIT_LIST_HEAD(&dev->mode_config.crtc_list);
		5318	INIT_LIST_HEAD(&dev->mode_config.connector_list);
		5319	INIT_LIST_HEAD(&dev->mode_config.encoder_list);
		5320	INIT_LIST_HEAD(&dev->mode_config.property_list);
		5321	INIT_LIST_HEAD(&dev->mode_config.property_blob_list);
		5322	INIT_LIST_HEAD(&dev->mode_config.plane_list);
		5323	idr_init(&dev->mode_config.crtc_idr);
5271	serge	5324	idr_init(&dev->mode_config.tile_idr);
6937	serge	5325	ida_init(&dev->mode_config.connector_ida);
3746	Serge	5326
		5327	drm_modeset_lock_all(dev);
6084	serge	5328	drm_mode_create_standard_properties(dev);
3746	Serge	5329	drm_modeset_unlock_all(dev);
		5330
		5331	/* Just to be sure */
		5332	dev->mode_config.num_fb = 0;
		5333	dev->mode_config.num_connector = 0;
		5334	dev->mode_config.num_crtc = 0;
		5335	dev->mode_config.num_encoder = 0;
5060	serge	5336	dev->mode_config.num_overlay_plane = 0;
		5337	dev->mode_config.num_total_plane = 0;
3746	Serge	5338	}
		5339	EXPORT_SYMBOL(drm_mode_config_init);
		5340
5060	serge	5341	/**
		5342	* drm_mode_config_cleanup - free up DRM mode_config info
		5343	* @dev: DRM device
		5344	*
		5345	* Free up all the connectors and CRTCs associated with this DRM device, then
		5346	* free up the framebuffers and associated buffer objects.
		5347	*
		5348	* Note that since this /should/ happen single-threaded at driver/device
		5349	* teardown time, no locking is required. It's the driver's job to ensure that
		5350	* this guarantee actually holds true.
		5351	*
		5352	* FIXME: cleanup any dangling user buffer objects too
		5353	*/
5271	serge	5354	void drm_mode_config_cleanup(struct drm_device *dev)
		5355	{
		5356	struct drm_connector connector, ot;
		5357	struct drm_crtc crtc, ct;
		5358	struct drm_encoder encoder, enct;
		5359	struct drm_framebuffer fb, fbt;
		5360	struct drm_property property, pt;
		5361	struct drm_property_blob blob, bt;
		5362	struct drm_plane plane, plt;
		5363
		5364	list_for_each_entry_safe(encoder, enct, &dev->mode_config.encoder_list,
		5365	head) {
		5366	encoder->funcs->destroy(encoder);
		5367	}
		5368
		5369	list_for_each_entry_safe(connector, ot,
		5370	&dev->mode_config.connector_list, head) {
		5371	connector->funcs->destroy(connector);
		5372	}
		5373
		5374	list_for_each_entry_safe(property, pt, &dev->mode_config.property_list,
		5375	head) {
		5376	drm_property_destroy(dev, property);
		5377	}
		5378
		5379	list_for_each_entry_safe(blob, bt, &dev->mode_config.property_blob_list,
6084	serge	5380	head_global) {
		5381	drm_property_unreference_blob(blob);
5271	serge	5382	}
		5383
		5384	/*
		5385	* Single-threaded teardown context, so it's not required to grab the
		5386	* fb_lock to protect against concurrent fb_list access. Contrary, it
		5387	* would actually deadlock with the drm_framebuffer_cleanup function.
		5388	*
		5389	* Also, if there are any framebuffers left, that's a driver leak now,
		5390	* so politely WARN about this.
		5391	*/
		5392	WARN_ON(!list_empty(&dev->mode_config.fb_list));
		5393	list_for_each_entry_safe(fb, fbt, &dev->mode_config.fb_list, head) {
6084	serge	5394	drm_framebuffer_free(&fb->refcount);
5271	serge	5395	}
		5396
		5397	list_for_each_entry_safe(plane, plt, &dev->mode_config.plane_list,
		5398	head) {
		5399	plane->funcs->destroy(plane);
		5400	}
		5401
		5402	list_for_each_entry_safe(crtc, ct, &dev->mode_config.crtc_list, head) {
		5403	crtc->funcs->destroy(crtc);
		5404	}
		5405
6937	serge	5406	ida_destroy(&dev->mode_config.connector_ida);
5271	serge	5407	idr_destroy(&dev->mode_config.tile_idr);
		5408	idr_destroy(&dev->mode_config.crtc_idr);
		5409	drm_modeset_lock_fini(&dev->mode_config.connection_mutex);
		5410	}
		5411	EXPORT_SYMBOL(drm_mode_config_cleanup);
		5412
		5413	struct drm_property drm_mode_create_rotation_property(struct drm_device dev,
		5414	unsigned int supported_rotations)
		5415	{
		5416	static const struct drm_prop_enum_list props[] = {
		5417	{ DRM_ROTATE_0, "rotate-0" },
		5418	{ DRM_ROTATE_90, "rotate-90" },
		5419	{ DRM_ROTATE_180, "rotate-180" },
		5420	{ DRM_ROTATE_270, "rotate-270" },
		5421	{ DRM_REFLECT_X, "reflect-x" },
		5422	{ DRM_REFLECT_Y, "reflect-y" },
		5423	};
		5424
		5425	return drm_property_create_bitmask(dev, 0, "rotation",
		5426	props, ARRAY_SIZE(props),
		5427	supported_rotations);
		5428	}
		5429	EXPORT_SYMBOL(drm_mode_create_rotation_property);
		5430
		5431	/**
		5432	* DOC: Tile group
		5433	*
		5434	* Tile groups are used to represent tiled monitors with a unique
		5435	* integer identifier. Tiled monitors using DisplayID v1.3 have
		5436	* a unique 8-byte handle, we store this in a tile group, so we
		5437	* have a common identifier for all tiles in a monitor group.
		5438	*/
		5439	static void drm_tile_group_free(struct kref *kref)
		5440	{
		5441	struct drm_tile_group *tg = container_of(kref, struct drm_tile_group, refcount);
		5442	struct drm_device *dev = tg->dev;
		5443	mutex_lock(&dev->mode_config.idr_mutex);
		5444	idr_remove(&dev->mode_config.tile_idr, tg->id);
		5445	mutex_unlock(&dev->mode_config.idr_mutex);
		5446	kfree(tg);
		5447	}
		5448
		5449	/**
		5450	* drm_mode_put_tile_group - drop a reference to a tile group.
		5451	* @dev: DRM device
		5452	* @tg: tile group to drop reference to.
		5453	*
		5454	* drop reference to tile group and free if 0.
		5455	*/
		5456	void drm_mode_put_tile_group(struct drm_device *dev,
		5457	struct drm_tile_group *tg)
		5458	{
		5459	kref_put(&tg->refcount, drm_tile_group_free);
		5460	}
		5461
		5462	/**
		5463	* drm_mode_get_tile_group - get a reference to an existing tile group
		5464	* @dev: DRM device
		5465	* @topology: 8-bytes unique per monitor.
		5466	*
		5467	* Use the unique bytes to get a reference to an existing tile group.
		5468	*
		5469	* RETURNS:
		5470	* tile group or NULL if not found.
		5471	*/
		5472	struct drm_tile_group drm_mode_get_tile_group(struct drm_device dev,
		5473	char topology[8])
		5474	{
		5475	struct drm_tile_group *tg;
		5476	int id;
		5477	mutex_lock(&dev->mode_config.idr_mutex);
		5478	idr_for_each_entry(&dev->mode_config.tile_idr, tg, id) {
		5479	if (!memcmp(tg->group_data, topology, 8)) {
6084	serge	5480	if (!kref_get_unless_zero(&tg->refcount))
		5481	tg = NULL;
5271	serge	5482	mutex_unlock(&dev->mode_config.idr_mutex);
		5483	return tg;
		5484	}
		5485	}
		5486	mutex_unlock(&dev->mode_config.idr_mutex);
		5487	return NULL;
		5488	}
6084	serge	5489	EXPORT_SYMBOL(drm_mode_get_tile_group);
5271	serge	5490
		5491	/**
		5492	* drm_mode_create_tile_group - create a tile group from a displayid description
		5493	* @dev: DRM device
		5494	* @topology: 8-bytes unique per monitor.
		5495	*
		5496	* Create a tile group for the unique monitor, and get a unique
		5497	* identifier for the tile group.
		5498	*
		5499	* RETURNS:
		5500	* new tile group or error.
		5501	*/
		5502	struct drm_tile_group drm_mode_create_tile_group(struct drm_device dev,
		5503	char topology[8])
		5504	{
		5505	struct drm_tile_group *tg;
		5506	int ret;
		5507
		5508	tg = kzalloc(sizeof(*tg), GFP_KERNEL);
		5509	if (!tg)
		5510	return ERR_PTR(-ENOMEM);
		5511
		5512	kref_init(&tg->refcount);
		5513	memcpy(tg->group_data, topology, 8);
		5514	tg->dev = dev;
		5515
		5516	mutex_lock(&dev->mode_config.idr_mutex);
		5517	ret = idr_alloc(&dev->mode_config.tile_idr, tg, 1, 0, GFP_KERNEL);
		5518	if (ret >= 0) {
		5519	tg->id = ret;
		5520	} else {
		5521	kfree(tg);
		5522	tg = ERR_PTR(ret);
		5523	}
		5524
		5525	mutex_unlock(&dev->mode_config.idr_mutex);
		5526	return tg;
		5527	}
6084	serge	5528	EXPORT_SYMBOL(drm_mode_create_tile_group);

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/drm_crtc.c – Rev 6937