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

Subversion Repositories Kolibri OS

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