Kalle Valo says:
[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_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  */
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
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
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
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
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
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
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
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
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
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
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)
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  */
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
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)
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  */
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
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  */
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  */
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
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  */
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  */
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  */
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;
719         int i;
720
721         if (!drm_core_check_feature(dev, DRIVER_MODESET))
722                 return -EOPNOTSUPP;
723
724         /*
725          * Universal plane src offsets are only 16.16, prevent havoc for
726          * drivers using universal plane code internally.
727          */
728         if (crtc_req->x & 0xffff0000 || crtc_req->y & 0xffff0000)
729                 return -ERANGE;
730
731         crtc = drm_crtc_find(dev, file_priv, crtc_req->crtc_id);
732         if (!crtc) {
733                 DRM_DEBUG_KMS("Unknown CRTC ID %d\n", crtc_req->crtc_id);
734                 return -ENOENT;
735         }
736         DRM_DEBUG_KMS("[CRTC:%d:%s]\n", crtc->base.id, crtc->name);
737
738         plane = crtc->primary;
739
740         /* allow disabling with the primary plane leased */
741         if (crtc_req->mode_valid && !drm_lease_held(file_priv, plane->base.id))
742                 return -EACCES;
743
744         DRM_MODESET_LOCK_ALL_BEGIN(dev, ctx,
745                                    DRM_MODESET_ACQUIRE_INTERRUPTIBLE, ret);
746
747         if (crtc_req->mode_valid) {
748                 /* If we have a mode we need a framebuffer. */
749                 /* If we pass -1, set the mode with the currently bound fb */
750                 if (crtc_req->fb_id == -1) {
751                         struct drm_framebuffer *old_fb;
752
753                         if (plane->state)
754                                 old_fb = plane->state->fb;
755                         else
756                                 old_fb = plane->fb;
757
758                         if (!old_fb) {
759                                 DRM_DEBUG_KMS("CRTC doesn't have current FB\n");
760                                 ret = -EINVAL;
761                                 goto out;
762                         }
763
764                         fb = old_fb;
765                         /* Make refcounting symmetric with the lookup path. */
766                         drm_framebuffer_get(fb);
767                 } else {
768                         fb = drm_framebuffer_lookup(dev, file_priv, crtc_req->fb_id);
769                         if (!fb) {
770                                 DRM_DEBUG_KMS("Unknown FB ID%d\n",
771                                                 crtc_req->fb_id);
772                                 ret = -ENOENT;
773                                 goto out;
774                         }
775                 }
776
777                 mode = drm_mode_create(dev);
778                 if (!mode) {
779                         ret = -ENOMEM;
780                         goto out;
781                 }
782                 if (!file_priv->aspect_ratio_allowed &&
783                     (crtc_req->mode.flags & DRM_MODE_FLAG_PIC_AR_MASK) != DRM_MODE_FLAG_PIC_AR_NONE) {
784                         DRM_DEBUG_KMS("Unexpected aspect-ratio flag bits\n");
785                         ret = -EINVAL;
786                         goto out;
787                 }
788
789
790                 ret = drm_mode_convert_umode(dev, mode, &crtc_req->mode);
791                 if (ret) {
792                         DRM_DEBUG_KMS("Invalid mode (ret=%d, status=%s)\n",
793                                       ret, drm_get_mode_status_name(mode->status));
794                         drm_mode_debug_printmodeline(mode);
795                         goto out;
796                 }
797
798                 /*
799                  * Check whether the primary plane supports the fb pixel format.
800                  * Drivers not implementing the universal planes API use a
801                  * default formats list provided by the DRM core which doesn't
802                  * match real hardware capabilities. Skip the check in that
803                  * case.
804                  */
805                 if (!plane->format_default) {
806                         ret = drm_plane_check_pixel_format(plane,
807                                                            fb->format->format,
808                                                            fb->modifier);
809                         if (ret) {
810                                 DRM_DEBUG_KMS("Invalid pixel format %p4cc, modifier 0x%llx\n",
811                                               &fb->format->format,
812                                               fb->modifier);
813                                 goto out;
814                         }
815                 }
816
817                 ret = drm_crtc_check_viewport(crtc, crtc_req->x, crtc_req->y,
818                                               mode, fb);
819                 if (ret)
820                         goto out;
821
822         }
823
824         if (crtc_req->count_connectors == 0 && mode) {
825                 DRM_DEBUG_KMS("Count connectors is 0 but mode set\n");
826                 ret = -EINVAL;
827                 goto out;
828         }
829
830         if (crtc_req->count_connectors > 0 && (!mode || !fb)) {
831                 DRM_DEBUG_KMS("Count connectors is %d but no mode or fb set\n",
832                           crtc_req->count_connectors);
833                 ret = -EINVAL;
834                 goto out;
835         }
836
837         if (crtc_req->count_connectors > 0) {
838                 u32 out_id;
839
840                 /* Avoid unbounded kernel memory allocation */
841                 if (crtc_req->count_connectors > config->num_connector) {
842                         ret = -EINVAL;
843                         goto out;
844                 }
845
846                 connector_set = kmalloc_array(crtc_req->count_connectors,
847                                               sizeof(struct drm_connector *),
848                                               GFP_KERNEL);
849                 if (!connector_set) {
850                         ret = -ENOMEM;
851                         goto out;
852                 }
853
854                 for (i = 0; i < crtc_req->count_connectors; i++) {
855                         connector_set[i] = NULL;
856                         set_connectors_ptr = (uint32_t __user *)(unsigned long)crtc_req->set_connectors_ptr;
857                         if (get_user(out_id, &set_connectors_ptr[i])) {
858                                 ret = -EFAULT;
859                                 goto out;
860                         }
861
862                         connector = drm_connector_lookup(dev, file_priv, out_id);
863                         if (!connector) {
864                                 DRM_DEBUG_KMS("Connector id %d unknown\n",
865                                                 out_id);
866                                 ret = -ENOENT;
867                                 goto out;
868                         }
869                         DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n",
870                                         connector->base.id,
871                                         connector->name);
872
873                         connector_set[i] = connector;
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 = crtc_req->count_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 < crtc_req->count_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
908         DRM_MODESET_LOCK_ALL_END(dev, ctx, ret);
909
910         return ret;
911 }
912
913 int drm_mode_crtc_set_obj_prop(struct drm_mode_object *obj,
914                                struct drm_property *property,
915                                uint64_t value)
916 {
917         int ret = -EINVAL;
918         struct drm_crtc *crtc = obj_to_crtc(obj);
919
920         if (crtc->funcs->set_property)
921                 ret = crtc->funcs->set_property(crtc, property, value);
922         if (!ret)
923                 drm_object_property_set_value(obj, property, value);
924
925         return ret;
926 }
927
928 /**
929  * drm_crtc_create_scaling_filter_property - create a new scaling filter
930  * property
931  *
932  * @crtc: drm CRTC
933  * @supported_filters: bitmask of supported scaling filters, must include
934  *                     BIT(DRM_SCALING_FILTER_DEFAULT).
935  *
936  * This function lets driver to enable the scaling filter property on a given
937  * CRTC.
938  *
939  * RETURNS:
940  * Zero for success or -errno
941  */
942 int drm_crtc_create_scaling_filter_property(struct drm_crtc *crtc,
943                                             unsigned int supported_filters)
944 {
945         struct drm_property *prop =
946                 drm_create_scaling_filter_prop(crtc->dev, supported_filters);
947
948         if (IS_ERR(prop))
949                 return PTR_ERR(prop);
950
951         drm_object_attach_property(&crtc->base, prop,
952                                    DRM_SCALING_FILTER_DEFAULT);
953         crtc->scaling_filter_property = prop;
954
955         return 0;
956 }
957 EXPORT_SYMBOL(drm_crtc_create_scaling_filter_property);