xref: /openbmc/linux/drivers/gpu/drm/drm_crtc.c (revision be6c52b0)
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 <linux/dma-fence.h>
37 #include <linux/uaccess.h>
38 #include <drm/drm_blend.h>
39 #include <drm/drm_crtc.h>
40 #include <drm/drm_edid.h>
41 #include <drm/drm_fourcc.h>
42 #include <drm/drm_framebuffer.h>
43 #include <drm/drm_managed.h>
44 #include <drm/drm_modeset_lock.h>
45 #include <drm/drm_atomic.h>
46 #include <drm/drm_auth.h>
47 #include <drm/drm_debugfs_crc.h>
48 #include <drm/drm_drv.h>
49 #include <drm/drm_print.h>
50 #include <drm/drm_file.h>
51 
52 #include "drm_crtc_internal.h"
53 #include "drm_internal.h"
54 
55 /**
56  * DOC: overview
57  *
58  * A CRTC represents the overall display pipeline. It receives pixel data from
59  * &drm_plane and blends them together. The &drm_display_mode is also attached
60  * to the CRTC, specifying display timings. On the output side the data is fed
61  * to one or more &drm_encoder, which are then each connected to one
62  * &drm_connector.
63  *
64  * To create a CRTC, a KMS drivers allocates and zeroes an instances of
65  * &struct drm_crtc (possibly as part of a larger structure) and registers it
66  * with a call to drm_crtc_init_with_planes().
67  *
68  * The CRTC is also the entry point for legacy modeset operations, see
69  * &drm_crtc_funcs.set_config, legacy plane operations, see
70  * &drm_crtc_funcs.page_flip and &drm_crtc_funcs.cursor_set2, and other legacy
71  * operations like &drm_crtc_funcs.gamma_set. For atomic drivers all these
72  * features are controlled through &drm_property and
73  * &drm_mode_config_funcs.atomic_check.
74  */
75 
76 /**
77  * drm_crtc_from_index - find the registered CRTC at an index
78  * @dev: DRM device
79  * @idx: index of registered CRTC to find for
80  *
81  * Given a CRTC index, return the registered CRTC from DRM device's
82  * list of CRTCs with matching index. This is the inverse of drm_crtc_index().
83  * It's useful in the vblank callbacks (like &drm_driver.enable_vblank or
84  * &drm_driver.disable_vblank), since that still deals with indices instead
85  * of pointers to &struct drm_crtc."
86  */
drm_crtc_from_index(struct drm_device * dev,int idx)87 struct drm_crtc *drm_crtc_from_index(struct drm_device *dev, int idx)
88 {
89 	struct drm_crtc *crtc;
90 
91 	drm_for_each_crtc(crtc, dev)
92 		if (idx == crtc->index)
93 			return crtc;
94 
95 	return NULL;
96 }
97 EXPORT_SYMBOL(drm_crtc_from_index);
98 
drm_crtc_force_disable(struct drm_crtc * crtc)99 int drm_crtc_force_disable(struct drm_crtc *crtc)
100 {
101 	struct drm_mode_set set = {
102 		.crtc = crtc,
103 	};
104 
105 	WARN_ON(drm_drv_uses_atomic_modeset(crtc->dev));
106 
107 	return drm_mode_set_config_internal(&set);
108 }
109 
drm_num_crtcs(struct drm_device * dev)110 static unsigned int drm_num_crtcs(struct drm_device *dev)
111 {
112 	unsigned int num = 0;
113 	struct drm_crtc *tmp;
114 
115 	drm_for_each_crtc(tmp, dev) {
116 		num++;
117 	}
118 
119 	return num;
120 }
121 
drm_crtc_register_all(struct drm_device * dev)122 int drm_crtc_register_all(struct drm_device *dev)
123 {
124 	struct drm_crtc *crtc;
125 	int ret = 0;
126 
127 	drm_for_each_crtc(crtc, dev) {
128 		drm_debugfs_crtc_add(crtc);
129 
130 		if (crtc->funcs->late_register)
131 			ret = crtc->funcs->late_register(crtc);
132 		if (ret)
133 			return ret;
134 	}
135 
136 	return 0;
137 }
138 
drm_crtc_unregister_all(struct drm_device * dev)139 void drm_crtc_unregister_all(struct drm_device *dev)
140 {
141 	struct drm_crtc *crtc;
142 
143 	drm_for_each_crtc(crtc, dev) {
144 		if (crtc->funcs->early_unregister)
145 			crtc->funcs->early_unregister(crtc);
146 		drm_debugfs_crtc_remove(crtc);
147 	}
148 }
149 
drm_crtc_crc_init(struct drm_crtc * crtc)150 static int drm_crtc_crc_init(struct drm_crtc *crtc)
151 {
152 #ifdef CONFIG_DEBUG_FS
153 	spin_lock_init(&crtc->crc.lock);
154 	init_waitqueue_head(&crtc->crc.wq);
155 	crtc->crc.source = kstrdup("auto", GFP_KERNEL);
156 	if (!crtc->crc.source)
157 		return -ENOMEM;
158 #endif
159 	return 0;
160 }
161 
drm_crtc_crc_fini(struct drm_crtc * crtc)162 static void drm_crtc_crc_fini(struct drm_crtc *crtc)
163 {
164 #ifdef CONFIG_DEBUG_FS
165 	kfree(crtc->crc.source);
166 #endif
167 }
168 
169 static const struct dma_fence_ops drm_crtc_fence_ops;
170 
fence_to_crtc(struct dma_fence * fence)171 static struct drm_crtc *fence_to_crtc(struct dma_fence *fence)
172 {
173 	BUG_ON(fence->ops != &drm_crtc_fence_ops);
174 	return container_of(fence->lock, struct drm_crtc, fence_lock);
175 }
176 
drm_crtc_fence_get_driver_name(struct dma_fence * fence)177 static const char *drm_crtc_fence_get_driver_name(struct dma_fence *fence)
178 {
179 	struct drm_crtc *crtc = fence_to_crtc(fence);
180 
181 	return crtc->dev->driver->name;
182 }
183 
drm_crtc_fence_get_timeline_name(struct dma_fence * fence)184 static const char *drm_crtc_fence_get_timeline_name(struct dma_fence *fence)
185 {
186 	struct drm_crtc *crtc = fence_to_crtc(fence);
187 
188 	return crtc->timeline_name;
189 }
190 
191 static const struct dma_fence_ops drm_crtc_fence_ops = {
192 	.get_driver_name = drm_crtc_fence_get_driver_name,
193 	.get_timeline_name = drm_crtc_fence_get_timeline_name,
194 };
195 
drm_crtc_create_fence(struct drm_crtc * crtc)196 struct dma_fence *drm_crtc_create_fence(struct drm_crtc *crtc)
197 {
198 	struct dma_fence *fence;
199 
200 	fence = kzalloc(sizeof(*fence), GFP_KERNEL);
201 	if (!fence)
202 		return NULL;
203 
204 	dma_fence_init(fence, &drm_crtc_fence_ops, &crtc->fence_lock,
205 		       crtc->fence_context, ++crtc->fence_seqno);
206 
207 	return fence;
208 }
209 
210 /**
211  * DOC: standard CRTC properties
212  *
213  * DRM CRTCs have a few standardized properties:
214  *
215  * ACTIVE:
216  * 	Atomic property for setting the power state of the CRTC. When set to 1
217  * 	the CRTC will actively display content. When set to 0 the CRTC will be
218  * 	powered off. There is no expectation that user-space will reset CRTC
219  * 	resources like the mode and planes when setting ACTIVE to 0.
220  *
221  * 	User-space can rely on an ACTIVE change to 1 to never fail an atomic
222  * 	test as long as no other property has changed. If a change to ACTIVE
223  * 	fails an atomic test, this is a driver bug. For this reason setting
224  * 	ACTIVE to 0 must not release internal resources (like reserved memory
225  * 	bandwidth or clock generators).
226  *
227  * 	Note that the legacy DPMS property on connectors is internally routed
228  * 	to control this property for atomic drivers.
229  * MODE_ID:
230  * 	Atomic property for setting the CRTC display timings. The value is the
231  * 	ID of a blob containing the DRM mode info. To disable the CRTC,
232  * 	user-space must set this property to 0.
233  *
234  * 	Setting MODE_ID to 0 will release reserved resources for the CRTC.
235  * SCALING_FILTER:
236  * 	Atomic property for setting the scaling filter for CRTC scaler
237  *
238  * 	The value of this property can be one of the following:
239  *
240  * 	Default:
241  * 		Driver's default scaling filter
242  * 	Nearest Neighbor:
243  * 		Nearest Neighbor scaling filter
244  */
245 
246 __printf(6, 0)
__drm_crtc_init_with_planes(struct drm_device * dev,struct drm_crtc * crtc,struct drm_plane * primary,struct drm_plane * cursor,const struct drm_crtc_funcs * funcs,const char * name,va_list ap)247 static int __drm_crtc_init_with_planes(struct drm_device *dev, struct drm_crtc *crtc,
248 				       struct drm_plane *primary,
249 				       struct drm_plane *cursor,
250 				       const struct drm_crtc_funcs *funcs,
251 				       const char *name, va_list ap)
252 {
253 	struct drm_mode_config *config = &dev->mode_config;
254 	int ret;
255 
256 	WARN_ON(primary && primary->type != DRM_PLANE_TYPE_PRIMARY);
257 	WARN_ON(cursor && cursor->type != DRM_PLANE_TYPE_CURSOR);
258 
259 	/* crtc index is used with 32bit bitmasks */
260 	if (WARN_ON(config->num_crtc >= 32))
261 		return -EINVAL;
262 
263 	WARN_ON(drm_drv_uses_atomic_modeset(dev) &&
264 		(!funcs->atomic_destroy_state ||
265 		 !funcs->atomic_duplicate_state));
266 
267 	crtc->dev = dev;
268 	crtc->funcs = funcs;
269 
270 	INIT_LIST_HEAD(&crtc->commit_list);
271 	spin_lock_init(&crtc->commit_lock);
272 
273 	drm_modeset_lock_init(&crtc->mutex);
274 	ret = drm_mode_object_add(dev, &crtc->base, DRM_MODE_OBJECT_CRTC);
275 	if (ret)
276 		return ret;
277 
278 	if (name) {
279 		crtc->name = kvasprintf(GFP_KERNEL, name, ap);
280 	} else {
281 		crtc->name = kasprintf(GFP_KERNEL, "crtc-%d",
282 				       drm_num_crtcs(dev));
283 	}
284 	if (!crtc->name) {
285 		drm_mode_object_unregister(dev, &crtc->base);
286 		return -ENOMEM;
287 	}
288 
289 	crtc->fence_context = dma_fence_context_alloc(1);
290 	spin_lock_init(&crtc->fence_lock);
291 	snprintf(crtc->timeline_name, sizeof(crtc->timeline_name),
292 		 "CRTC:%d-%s", crtc->base.id, crtc->name);
293 
294 	crtc->base.properties = &crtc->properties;
295 
296 	list_add_tail(&crtc->head, &config->crtc_list);
297 	crtc->index = config->num_crtc++;
298 
299 	crtc->primary = primary;
300 	crtc->cursor = cursor;
301 	if (primary && !primary->possible_crtcs)
302 		primary->possible_crtcs = drm_crtc_mask(crtc);
303 	if (cursor && !cursor->possible_crtcs)
304 		cursor->possible_crtcs = drm_crtc_mask(crtc);
305 
306 	ret = drm_crtc_crc_init(crtc);
307 	if (ret) {
308 		drm_mode_object_unregister(dev, &crtc->base);
309 		return ret;
310 	}
311 
312 	if (drm_core_check_feature(dev, DRIVER_ATOMIC)) {
313 		drm_object_attach_property(&crtc->base, config->prop_active, 0);
314 		drm_object_attach_property(&crtc->base, config->prop_mode_id, 0);
315 		drm_object_attach_property(&crtc->base,
316 					   config->prop_out_fence_ptr, 0);
317 		drm_object_attach_property(&crtc->base,
318 					   config->prop_vrr_enabled, 0);
319 	}
320 
321 	return 0;
322 }
323 
324 /**
325  * drm_crtc_init_with_planes - Initialise a new CRTC object with
326  *    specified primary and cursor planes.
327  * @dev: DRM device
328  * @crtc: CRTC object to init
329  * @primary: Primary plane for CRTC
330  * @cursor: Cursor plane for CRTC
331  * @funcs: callbacks for the new CRTC
332  * @name: printf style format string for the CRTC name, or NULL for default name
333  *
334  * Inits a new object created as base part of a driver crtc object. Drivers
335  * should use this function instead of drm_crtc_init(), which is only provided
336  * for backwards compatibility with drivers which do not yet support universal
337  * planes). For really simple hardware which has only 1 plane look at
338  * drm_simple_display_pipe_init() instead.
339  * The &drm_crtc_funcs.destroy hook should call drm_crtc_cleanup() and kfree()
340  * the crtc structure. The crtc structure should not be allocated with
341  * devm_kzalloc().
342  *
343  * The @primary and @cursor planes are only relevant for legacy uAPI, see
344  * &drm_crtc.primary and &drm_crtc.cursor.
345  *
346  * Note: consider using drmm_crtc_alloc_with_planes() or
347  * drmm_crtc_init_with_planes() instead of drm_crtc_init_with_planes()
348  * to let the DRM managed resource infrastructure take care of cleanup
349  * and deallocation.
350  *
351  * Returns:
352  * Zero on success, error code on failure.
353  */
drm_crtc_init_with_planes(struct drm_device * dev,struct drm_crtc * crtc,struct drm_plane * primary,struct drm_plane * cursor,const struct drm_crtc_funcs * funcs,const char * name,...)354 int drm_crtc_init_with_planes(struct drm_device *dev, struct drm_crtc *crtc,
355 			      struct drm_plane *primary,
356 			      struct drm_plane *cursor,
357 			      const struct drm_crtc_funcs *funcs,
358 			      const char *name, ...)
359 {
360 	va_list ap;
361 	int ret;
362 
363 	WARN_ON(!funcs->destroy);
364 
365 	va_start(ap, name);
366 	ret = __drm_crtc_init_with_planes(dev, crtc, primary, cursor, funcs,
367 					  name, ap);
368 	va_end(ap);
369 
370 	return ret;
371 }
372 EXPORT_SYMBOL(drm_crtc_init_with_planes);
373 
drmm_crtc_init_with_planes_cleanup(struct drm_device * dev,void * ptr)374 static void drmm_crtc_init_with_planes_cleanup(struct drm_device *dev,
375 					       void *ptr)
376 {
377 	struct drm_crtc *crtc = ptr;
378 
379 	drm_crtc_cleanup(crtc);
380 }
381 
382 __printf(6, 0)
__drmm_crtc_init_with_planes(struct drm_device * dev,struct drm_crtc * crtc,struct drm_plane * primary,struct drm_plane * cursor,const struct drm_crtc_funcs * funcs,const char * name,va_list args)383 static int __drmm_crtc_init_with_planes(struct drm_device *dev,
384 					struct drm_crtc *crtc,
385 					struct drm_plane *primary,
386 					struct drm_plane *cursor,
387 					const struct drm_crtc_funcs *funcs,
388 					const char *name,
389 					va_list args)
390 {
391 	int ret;
392 
393 	drm_WARN_ON(dev, funcs && funcs->destroy);
394 
395 	ret = __drm_crtc_init_with_planes(dev, crtc, primary, cursor, funcs,
396 					  name, args);
397 	if (ret)
398 		return ret;
399 
400 	ret = drmm_add_action_or_reset(dev, drmm_crtc_init_with_planes_cleanup,
401 				       crtc);
402 	if (ret)
403 		return ret;
404 
405 	return 0;
406 }
407 
408 /**
409  * drmm_crtc_init_with_planes - Initialise a new CRTC object with
410  *    specified primary and cursor planes.
411  * @dev: DRM device
412  * @crtc: CRTC object to init
413  * @primary: Primary plane for CRTC
414  * @cursor: Cursor plane for CRTC
415  * @funcs: callbacks for the new CRTC
416  * @name: printf style format string for the CRTC name, or NULL for default name
417  *
418  * Inits a new object created as base part of a driver crtc object. Drivers
419  * should use this function instead of drm_crtc_init(), which is only provided
420  * for backwards compatibility with drivers which do not yet support universal
421  * planes). For really simple hardware which has only 1 plane look at
422  * drm_simple_display_pipe_init() instead.
423  *
424  * Cleanup is automatically handled through registering
425  * drmm_crtc_cleanup() with drmm_add_action(). The crtc structure should
426  * be allocated with drmm_kzalloc().
427  *
428  * The @drm_crtc_funcs.destroy hook must be NULL.
429  *
430  * The @primary and @cursor planes are only relevant for legacy uAPI, see
431  * &drm_crtc.primary and &drm_crtc.cursor.
432  *
433  * Returns:
434  * Zero on success, error code on failure.
435  */
drmm_crtc_init_with_planes(struct drm_device * dev,struct drm_crtc * crtc,struct drm_plane * primary,struct drm_plane * cursor,const struct drm_crtc_funcs * funcs,const char * name,...)436 int drmm_crtc_init_with_planes(struct drm_device *dev, struct drm_crtc *crtc,
437 			       struct drm_plane *primary,
438 			       struct drm_plane *cursor,
439 			       const struct drm_crtc_funcs *funcs,
440 			       const char *name, ...)
441 {
442 	va_list ap;
443 	int ret;
444 
445 	va_start(ap, name);
446 	ret = __drmm_crtc_init_with_planes(dev, crtc, primary, cursor, funcs,
447 					   name, ap);
448 	va_end(ap);
449 	if (ret)
450 		return ret;
451 
452 	return 0;
453 }
454 EXPORT_SYMBOL(drmm_crtc_init_with_planes);
455 
__drmm_crtc_alloc_with_planes(struct drm_device * dev,size_t size,size_t offset,struct drm_plane * primary,struct drm_plane * cursor,const struct drm_crtc_funcs * funcs,const char * name,...)456 void *__drmm_crtc_alloc_with_planes(struct drm_device *dev,
457 				    size_t size, size_t offset,
458 				    struct drm_plane *primary,
459 				    struct drm_plane *cursor,
460 				    const struct drm_crtc_funcs *funcs,
461 				    const char *name, ...)
462 {
463 	void *container;
464 	struct drm_crtc *crtc;
465 	va_list ap;
466 	int ret;
467 
468 	if (WARN_ON(!funcs || funcs->destroy))
469 		return ERR_PTR(-EINVAL);
470 
471 	container = drmm_kzalloc(dev, size, GFP_KERNEL);
472 	if (!container)
473 		return ERR_PTR(-ENOMEM);
474 
475 	crtc = container + offset;
476 
477 	va_start(ap, name);
478 	ret = __drmm_crtc_init_with_planes(dev, crtc, primary, cursor, funcs,
479 					   name, ap);
480 	va_end(ap);
481 	if (ret)
482 		return ERR_PTR(ret);
483 
484 	return container;
485 }
486 EXPORT_SYMBOL(__drmm_crtc_alloc_with_planes);
487 
488 /**
489  * drm_crtc_cleanup - Clean up the core crtc usage
490  * @crtc: CRTC to cleanup
491  *
492  * This function cleans up @crtc and removes it from the DRM mode setting
493  * core. Note that the function does *not* free the crtc structure itself,
494  * this is the responsibility of the caller.
495  */
drm_crtc_cleanup(struct drm_crtc * crtc)496 void drm_crtc_cleanup(struct drm_crtc *crtc)
497 {
498 	struct drm_device *dev = crtc->dev;
499 
500 	/* Note that the crtc_list is considered to be static; should we
501 	 * remove the drm_crtc at runtime we would have to decrement all
502 	 * the indices on the drm_crtc after us in the crtc_list.
503 	 */
504 
505 	drm_crtc_crc_fini(crtc);
506 
507 	kfree(crtc->gamma_store);
508 	crtc->gamma_store = NULL;
509 
510 	drm_modeset_lock_fini(&crtc->mutex);
511 
512 	drm_mode_object_unregister(dev, &crtc->base);
513 	list_del(&crtc->head);
514 	dev->mode_config.num_crtc--;
515 
516 	WARN_ON(crtc->state && !crtc->funcs->atomic_destroy_state);
517 	if (crtc->state && crtc->funcs->atomic_destroy_state)
518 		crtc->funcs->atomic_destroy_state(crtc, crtc->state);
519 
520 	kfree(crtc->name);
521 
522 	memset(crtc, 0, sizeof(*crtc));
523 }
524 EXPORT_SYMBOL(drm_crtc_cleanup);
525 
526 /**
527  * drm_mode_getcrtc - get CRTC configuration
528  * @dev: drm device for the ioctl
529  * @data: data pointer for the ioctl
530  * @file_priv: drm file for the ioctl call
531  *
532  * Construct a CRTC configuration structure to return to the user.
533  *
534  * Called by the user via ioctl.
535  *
536  * Returns:
537  * Zero on success, negative errno on failure.
538  */
drm_mode_getcrtc(struct drm_device * dev,void * data,struct drm_file * file_priv)539 int drm_mode_getcrtc(struct drm_device *dev,
540 		     void *data, struct drm_file *file_priv)
541 {
542 	struct drm_mode_crtc *crtc_resp = data;
543 	struct drm_crtc *crtc;
544 	struct drm_plane *plane;
545 
546 	if (!drm_core_check_feature(dev, DRIVER_MODESET))
547 		return -EOPNOTSUPP;
548 
549 	crtc = drm_crtc_find(dev, file_priv, crtc_resp->crtc_id);
550 	if (!crtc)
551 		return -ENOENT;
552 
553 	plane = crtc->primary;
554 
555 	crtc_resp->gamma_size = crtc->gamma_size;
556 
557 	drm_modeset_lock(&plane->mutex, NULL);
558 	if (plane->state && plane->state->fb)
559 		crtc_resp->fb_id = plane->state->fb->base.id;
560 	else if (!plane->state && plane->fb)
561 		crtc_resp->fb_id = plane->fb->base.id;
562 	else
563 		crtc_resp->fb_id = 0;
564 
565 	if (plane->state) {
566 		crtc_resp->x = plane->state->src_x >> 16;
567 		crtc_resp->y = plane->state->src_y >> 16;
568 	}
569 	drm_modeset_unlock(&plane->mutex);
570 
571 	drm_modeset_lock(&crtc->mutex, NULL);
572 	if (crtc->state) {
573 		if (crtc->state->enable) {
574 			drm_mode_convert_to_umode(&crtc_resp->mode, &crtc->state->mode);
575 			crtc_resp->mode_valid = 1;
576 		} else {
577 			crtc_resp->mode_valid = 0;
578 		}
579 	} else {
580 		crtc_resp->x = crtc->x;
581 		crtc_resp->y = crtc->y;
582 
583 		if (crtc->enabled) {
584 			drm_mode_convert_to_umode(&crtc_resp->mode, &crtc->mode);
585 			crtc_resp->mode_valid = 1;
586 
587 		} else {
588 			crtc_resp->mode_valid = 0;
589 		}
590 	}
591 	if (!file_priv->aspect_ratio_allowed)
592 		crtc_resp->mode.flags &= ~DRM_MODE_FLAG_PIC_AR_MASK;
593 	drm_modeset_unlock(&crtc->mutex);
594 
595 	return 0;
596 }
597 
__drm_mode_set_config_internal(struct drm_mode_set * set,struct drm_modeset_acquire_ctx * ctx)598 static int __drm_mode_set_config_internal(struct drm_mode_set *set,
599 					  struct drm_modeset_acquire_ctx *ctx)
600 {
601 	struct drm_crtc *crtc = set->crtc;
602 	struct drm_framebuffer *fb;
603 	struct drm_crtc *tmp;
604 	int ret;
605 
606 	WARN_ON(drm_drv_uses_atomic_modeset(crtc->dev));
607 
608 	/*
609 	 * NOTE: ->set_config can also disable other crtcs (if we steal all
610 	 * connectors from it), hence we need to refcount the fbs across all
611 	 * crtcs. Atomic modeset will have saner semantics ...
612 	 */
613 	drm_for_each_crtc(tmp, crtc->dev) {
614 		struct drm_plane *plane = tmp->primary;
615 
616 		plane->old_fb = plane->fb;
617 	}
618 
619 	fb = set->fb;
620 
621 	ret = crtc->funcs->set_config(set, ctx);
622 	if (ret == 0) {
623 		struct drm_plane *plane = crtc->primary;
624 
625 		plane->crtc = fb ? crtc : NULL;
626 		plane->fb = fb;
627 	}
628 
629 	drm_for_each_crtc(tmp, crtc->dev) {
630 		struct drm_plane *plane = tmp->primary;
631 
632 		if (plane->fb)
633 			drm_framebuffer_get(plane->fb);
634 		if (plane->old_fb)
635 			drm_framebuffer_put(plane->old_fb);
636 		plane->old_fb = NULL;
637 	}
638 
639 	return ret;
640 }
641 
642 /**
643  * drm_mode_set_config_internal - helper to call &drm_mode_config_funcs.set_config
644  * @set: modeset config to set
645  *
646  * This is a little helper to wrap internal calls to the
647  * &drm_mode_config_funcs.set_config driver interface. The only thing it adds is
648  * correct refcounting dance.
649  *
650  * This should only be used by non-atomic legacy drivers.
651  *
652  * Returns:
653  * Zero on success, negative errno on failure.
654  */
drm_mode_set_config_internal(struct drm_mode_set * set)655 int drm_mode_set_config_internal(struct drm_mode_set *set)
656 {
657 	WARN_ON(drm_drv_uses_atomic_modeset(set->crtc->dev));
658 
659 	return __drm_mode_set_config_internal(set, NULL);
660 }
661 EXPORT_SYMBOL(drm_mode_set_config_internal);
662 
663 /**
664  * drm_crtc_check_viewport - Checks that a framebuffer is big enough for the
665  *     CRTC viewport
666  * @crtc: CRTC that framebuffer will be displayed on
667  * @x: x panning
668  * @y: y panning
669  * @mode: mode that framebuffer will be displayed under
670  * @fb: framebuffer to check size of
671  */
drm_crtc_check_viewport(const struct drm_crtc * crtc,int x,int y,const struct drm_display_mode * mode,const struct drm_framebuffer * fb)672 int drm_crtc_check_viewport(const struct drm_crtc *crtc,
673 			    int x, int y,
674 			    const struct drm_display_mode *mode,
675 			    const struct drm_framebuffer *fb)
676 
677 {
678 	int hdisplay, vdisplay;
679 
680 	drm_mode_get_hv_timing(mode, &hdisplay, &vdisplay);
681 
682 	if (crtc->state &&
683 	    drm_rotation_90_or_270(crtc->primary->state->rotation))
684 		swap(hdisplay, vdisplay);
685 
686 	return drm_framebuffer_check_src_coords(x << 16, y << 16,
687 						hdisplay << 16, vdisplay << 16,
688 						fb);
689 }
690 EXPORT_SYMBOL(drm_crtc_check_viewport);
691 
692 /**
693  * drm_mode_setcrtc - set CRTC configuration
694  * @dev: drm device for the ioctl
695  * @data: data pointer for the ioctl
696  * @file_priv: drm file for the ioctl call
697  *
698  * Build a new CRTC configuration based on user request.
699  *
700  * Called by the user via ioctl.
701  *
702  * Returns:
703  * Zero on success, negative errno on failure.
704  */
drm_mode_setcrtc(struct drm_device * dev,void * data,struct drm_file * file_priv)705 int drm_mode_setcrtc(struct drm_device *dev, void *data,
706 		     struct drm_file *file_priv)
707 {
708 	struct drm_mode_config *config = &dev->mode_config;
709 	struct drm_mode_crtc *crtc_req = data;
710 	struct drm_crtc *crtc;
711 	struct drm_plane *plane;
712 	struct drm_connector **connector_set = NULL, *connector;
713 	struct drm_framebuffer *fb = NULL;
714 	struct drm_display_mode *mode = NULL;
715 	struct drm_mode_set set;
716 	uint32_t __user *set_connectors_ptr;
717 	struct drm_modeset_acquire_ctx ctx;
718 	int ret, i, num_connectors = 0;
719 
720 	if (!drm_core_check_feature(dev, DRIVER_MODESET))
721 		return -EOPNOTSUPP;
722 
723 	/*
724 	 * Universal plane src offsets are only 16.16, prevent havoc for
725 	 * drivers using universal plane code internally.
726 	 */
727 	if (crtc_req->x & 0xffff0000 || crtc_req->y & 0xffff0000)
728 		return -ERANGE;
729 
730 	crtc = drm_crtc_find(dev, file_priv, crtc_req->crtc_id);
731 	if (!crtc) {
732 		DRM_DEBUG_KMS("Unknown CRTC ID %d\n", crtc_req->crtc_id);
733 		return -ENOENT;
734 	}
735 	DRM_DEBUG_KMS("[CRTC:%d:%s]\n", crtc->base.id, crtc->name);
736 
737 	plane = crtc->primary;
738 
739 	/* allow disabling with the primary plane leased */
740 	if (crtc_req->mode_valid && !drm_lease_held(file_priv, plane->base.id))
741 		return -EACCES;
742 
743 	DRM_MODESET_LOCK_ALL_BEGIN(dev, ctx,
744 				   DRM_MODESET_ACQUIRE_INTERRUPTIBLE, ret);
745 
746 	if (crtc_req->mode_valid) {
747 		/* If we have a mode we need a framebuffer. */
748 		/* If we pass -1, set the mode with the currently bound fb */
749 		if (crtc_req->fb_id == -1) {
750 			struct drm_framebuffer *old_fb;
751 
752 			if (plane->state)
753 				old_fb = plane->state->fb;
754 			else
755 				old_fb = plane->fb;
756 
757 			if (!old_fb) {
758 				DRM_DEBUG_KMS("CRTC doesn't have current FB\n");
759 				ret = -EINVAL;
760 				goto out;
761 			}
762 
763 			fb = old_fb;
764 			/* Make refcounting symmetric with the lookup path. */
765 			drm_framebuffer_get(fb);
766 		} else {
767 			fb = drm_framebuffer_lookup(dev, file_priv, crtc_req->fb_id);
768 			if (!fb) {
769 				DRM_DEBUG_KMS("Unknown FB ID%d\n",
770 						crtc_req->fb_id);
771 				ret = -ENOENT;
772 				goto out;
773 			}
774 		}
775 
776 		mode = drm_mode_create(dev);
777 		if (!mode) {
778 			ret = -ENOMEM;
779 			goto out;
780 		}
781 		if (!file_priv->aspect_ratio_allowed &&
782 		    (crtc_req->mode.flags & DRM_MODE_FLAG_PIC_AR_MASK) != DRM_MODE_FLAG_PIC_AR_NONE) {
783 			DRM_DEBUG_KMS("Unexpected aspect-ratio flag bits\n");
784 			ret = -EINVAL;
785 			goto out;
786 		}
787 
788 
789 		ret = drm_mode_convert_umode(dev, mode, &crtc_req->mode);
790 		if (ret) {
791 			DRM_DEBUG_KMS("Invalid mode (ret=%d, status=%s)\n",
792 				      ret, drm_get_mode_status_name(mode->status));
793 			drm_mode_debug_printmodeline(mode);
794 			goto out;
795 		}
796 
797 		/*
798 		 * Check whether the primary plane supports the fb pixel format.
799 		 * Drivers not implementing the universal planes API use a
800 		 * default formats list provided by the DRM core which doesn't
801 		 * match real hardware capabilities. Skip the check in that
802 		 * case.
803 		 */
804 		if (!plane->format_default) {
805 			ret = drm_plane_check_pixel_format(plane,
806 							   fb->format->format,
807 							   fb->modifier);
808 			if (ret) {
809 				DRM_DEBUG_KMS("Invalid pixel format %p4cc, modifier 0x%llx\n",
810 					      &fb->format->format,
811 					      fb->modifier);
812 				goto out;
813 			}
814 		}
815 
816 		ret = drm_crtc_check_viewport(crtc, crtc_req->x, crtc_req->y,
817 					      mode, fb);
818 		if (ret)
819 			goto out;
820 
821 	}
822 
823 	if (crtc_req->count_connectors == 0 && mode) {
824 		DRM_DEBUG_KMS("Count connectors is 0 but mode set\n");
825 		ret = -EINVAL;
826 		goto out;
827 	}
828 
829 	if (crtc_req->count_connectors > 0 && (!mode || !fb)) {
830 		DRM_DEBUG_KMS("Count connectors is %d but no mode or fb set\n",
831 			  crtc_req->count_connectors);
832 		ret = -EINVAL;
833 		goto out;
834 	}
835 
836 	if (crtc_req->count_connectors > 0) {
837 		u32 out_id;
838 
839 		/* Avoid unbounded kernel memory allocation */
840 		if (crtc_req->count_connectors > config->num_connector) {
841 			ret = -EINVAL;
842 			goto out;
843 		}
844 
845 		connector_set = kmalloc_array(crtc_req->count_connectors,
846 					      sizeof(struct drm_connector *),
847 					      GFP_KERNEL);
848 		if (!connector_set) {
849 			ret = -ENOMEM;
850 			goto out;
851 		}
852 
853 		for (i = 0; i < crtc_req->count_connectors; i++) {
854 			connector_set[i] = NULL;
855 			set_connectors_ptr = (uint32_t __user *)(unsigned long)crtc_req->set_connectors_ptr;
856 			if (get_user(out_id, &set_connectors_ptr[i])) {
857 				ret = -EFAULT;
858 				goto out;
859 			}
860 
861 			connector = drm_connector_lookup(dev, file_priv, out_id);
862 			if (!connector) {
863 				DRM_DEBUG_KMS("Connector id %d unknown\n",
864 						out_id);
865 				ret = -ENOENT;
866 				goto out;
867 			}
868 			DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n",
869 					connector->base.id,
870 					connector->name);
871 
872 			connector_set[i] = connector;
873 			num_connectors++;
874 		}
875 	}
876 
877 	set.crtc = crtc;
878 	set.x = crtc_req->x;
879 	set.y = crtc_req->y;
880 	set.mode = mode;
881 	set.connectors = connector_set;
882 	set.num_connectors = num_connectors;
883 	set.fb = fb;
884 
885 	if (drm_drv_uses_atomic_modeset(dev))
886 		ret = crtc->funcs->set_config(&set, &ctx);
887 	else
888 		ret = __drm_mode_set_config_internal(&set, &ctx);
889 
890 out:
891 	if (fb)
892 		drm_framebuffer_put(fb);
893 
894 	if (connector_set) {
895 		for (i = 0; i < num_connectors; i++) {
896 			if (connector_set[i])
897 				drm_connector_put(connector_set[i]);
898 		}
899 	}
900 	kfree(connector_set);
901 	drm_mode_destroy(dev, mode);
902 
903 	/* In case we need to retry... */
904 	connector_set = NULL;
905 	fb = NULL;
906 	mode = NULL;
907 	num_connectors = 0;
908 
909 	DRM_MODESET_LOCK_ALL_END(dev, ctx, ret);
910 
911 	return ret;
912 }
913 
drm_mode_crtc_set_obj_prop(struct drm_mode_object * obj,struct drm_property * property,uint64_t value)914 int drm_mode_crtc_set_obj_prop(struct drm_mode_object *obj,
915 			       struct drm_property *property,
916 			       uint64_t value)
917 {
918 	int ret = -EINVAL;
919 	struct drm_crtc *crtc = obj_to_crtc(obj);
920 
921 	if (crtc->funcs->set_property)
922 		ret = crtc->funcs->set_property(crtc, property, value);
923 	if (!ret)
924 		drm_object_property_set_value(obj, property, value);
925 
926 	return ret;
927 }
928 
929 /**
930  * drm_crtc_create_scaling_filter_property - create a new scaling filter
931  * property
932  *
933  * @crtc: drm CRTC
934  * @supported_filters: bitmask of supported scaling filters, must include
935  *		       BIT(DRM_SCALING_FILTER_DEFAULT).
936  *
937  * This function lets driver to enable the scaling filter property on a given
938  * CRTC.
939  *
940  * RETURNS:
941  * Zero for success or -errno
942  */
drm_crtc_create_scaling_filter_property(struct drm_crtc * crtc,unsigned int supported_filters)943 int drm_crtc_create_scaling_filter_property(struct drm_crtc *crtc,
944 					    unsigned int supported_filters)
945 {
946 	struct drm_property *prop =
947 		drm_create_scaling_filter_prop(crtc->dev, supported_filters);
948 
949 	if (IS_ERR(prop))
950 		return PTR_ERR(prop);
951 
952 	drm_object_attach_property(&crtc->base, prop,
953 				   DRM_SCALING_FILTER_DEFAULT);
954 	crtc->scaling_filter_property = prop;
955 
956 	return 0;
957 }
958 EXPORT_SYMBOL(drm_crtc_create_scaling_filter_property);
959