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