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);