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