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