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