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 */ 81 struct 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 } 91 EXPORT_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 */ 102 int 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 } 112 EXPORT_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 */ 127 int 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 } 139 out: 140 drm_modeset_unlock_all(dev); 141 return ret; 142 } 143 EXPORT_SYMBOL(drm_crtc_force_disable_all); 144 145 static 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 157 int 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 176 void 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 187 static 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 199 static void drm_crtc_crc_fini(struct drm_crtc *crtc) 200 { 201 #ifdef CONFIG_DEBUG_FS 202 kfree(crtc->crc.source); 203 #endif 204 } 205 206 static const struct dma_fence_ops drm_crtc_fence_ops; 207 208 static 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 214 static 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 221 static 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 228 static bool drm_crtc_fence_enable_signaling(struct dma_fence *fence) 229 { 230 return true; 231 } 232 233 static 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 240 struct 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 */ 273 int 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 } 347 EXPORT_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 */ 357 void 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 } 385 EXPORT_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 */ 400 int 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 struct drm_plane *plane; 406 407 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 408 return -EINVAL; 409 410 crtc = drm_crtc_find(dev, file_priv, crtc_resp->crtc_id); 411 if (!crtc) 412 return -ENOENT; 413 414 plane = crtc->primary; 415 416 crtc_resp->gamma_size = crtc->gamma_size; 417 418 drm_modeset_lock(&plane->mutex, NULL); 419 if (plane->state && plane->state->fb) 420 crtc_resp->fb_id = plane->state->fb->base.id; 421 else if (!plane->state && plane->fb) 422 crtc_resp->fb_id = plane->fb->base.id; 423 else 424 crtc_resp->fb_id = 0; 425 426 if (plane->state) { 427 crtc_resp->x = plane->state->src_x >> 16; 428 crtc_resp->y = plane->state->src_y >> 16; 429 } 430 drm_modeset_unlock(&plane->mutex); 431 432 drm_modeset_lock(&crtc->mutex, NULL); 433 if (crtc->state) { 434 if (crtc->state->enable) { 435 drm_mode_convert_to_umode(&crtc_resp->mode, &crtc->state->mode); 436 crtc_resp->mode_valid = 1; 437 } else { 438 crtc_resp->mode_valid = 0; 439 } 440 } else { 441 crtc_resp->x = crtc->x; 442 crtc_resp->y = crtc->y; 443 444 if (crtc->enabled) { 445 drm_mode_convert_to_umode(&crtc_resp->mode, &crtc->mode); 446 crtc_resp->mode_valid = 1; 447 448 } else { 449 crtc_resp->mode_valid = 0; 450 } 451 } 452 if (!file_priv->aspect_ratio_allowed) 453 crtc_resp->mode.flags &= ~DRM_MODE_FLAG_PIC_AR_MASK; 454 drm_modeset_unlock(&crtc->mutex); 455 456 return 0; 457 } 458 459 static int __drm_mode_set_config_internal(struct drm_mode_set *set, 460 struct drm_modeset_acquire_ctx *ctx) 461 { 462 struct drm_crtc *crtc = set->crtc; 463 struct drm_framebuffer *fb; 464 struct drm_crtc *tmp; 465 int ret; 466 467 /* 468 * NOTE: ->set_config can also disable other crtcs (if we steal all 469 * connectors from it), hence we need to refcount the fbs across all 470 * crtcs. Atomic modeset will have saner semantics ... 471 */ 472 drm_for_each_crtc(tmp, crtc->dev) 473 tmp->primary->old_fb = tmp->primary->fb; 474 475 fb = set->fb; 476 477 ret = crtc->funcs->set_config(set, ctx); 478 if (ret == 0) { 479 crtc->primary->crtc = fb ? crtc : NULL; 480 crtc->primary->fb = fb; 481 } 482 483 drm_for_each_crtc(tmp, crtc->dev) { 484 if (tmp->primary->fb) 485 drm_framebuffer_get(tmp->primary->fb); 486 if (tmp->primary->old_fb) 487 drm_framebuffer_put(tmp->primary->old_fb); 488 tmp->primary->old_fb = NULL; 489 } 490 491 return ret; 492 } 493 /** 494 * drm_mode_set_config_internal - helper to call &drm_mode_config_funcs.set_config 495 * @set: modeset config to set 496 * 497 * This is a little helper to wrap internal calls to the 498 * &drm_mode_config_funcs.set_config driver interface. The only thing it adds is 499 * correct refcounting dance. 500 * 501 * This should only be used by non-atomic legacy drivers. 502 * 503 * Returns: 504 * Zero on success, negative errno on failure. 505 */ 506 int drm_mode_set_config_internal(struct drm_mode_set *set) 507 { 508 WARN_ON(drm_drv_uses_atomic_modeset(set->crtc->dev)); 509 510 return __drm_mode_set_config_internal(set, NULL); 511 } 512 EXPORT_SYMBOL(drm_mode_set_config_internal); 513 514 /** 515 * drm_crtc_check_viewport - Checks that a framebuffer is big enough for the 516 * CRTC viewport 517 * @crtc: CRTC that framebuffer will be displayed on 518 * @x: x panning 519 * @y: y panning 520 * @mode: mode that framebuffer will be displayed under 521 * @fb: framebuffer to check size of 522 */ 523 int drm_crtc_check_viewport(const struct drm_crtc *crtc, 524 int x, int y, 525 const struct drm_display_mode *mode, 526 const struct drm_framebuffer *fb) 527 528 { 529 int hdisplay, vdisplay; 530 531 drm_mode_get_hv_timing(mode, &hdisplay, &vdisplay); 532 533 if (crtc->state && 534 drm_rotation_90_or_270(crtc->primary->state->rotation)) 535 swap(hdisplay, vdisplay); 536 537 return drm_framebuffer_check_src_coords(x << 16, y << 16, 538 hdisplay << 16, vdisplay << 16, 539 fb); 540 } 541 EXPORT_SYMBOL(drm_crtc_check_viewport); 542 543 /** 544 * drm_mode_setcrtc - set CRTC configuration 545 * @dev: drm device for the ioctl 546 * @data: data pointer for the ioctl 547 * @file_priv: drm file for the ioctl call 548 * 549 * Build a new CRTC configuration based on user request. 550 * 551 * Called by the user via ioctl. 552 * 553 * Returns: 554 * Zero on success, negative errno on failure. 555 */ 556 int drm_mode_setcrtc(struct drm_device *dev, void *data, 557 struct drm_file *file_priv) 558 { 559 struct drm_mode_config *config = &dev->mode_config; 560 struct drm_mode_crtc *crtc_req = data; 561 struct drm_crtc *crtc; 562 struct drm_plane *plane; 563 struct drm_connector **connector_set = NULL, *connector; 564 struct drm_framebuffer *fb = NULL; 565 struct drm_display_mode *mode = NULL; 566 struct drm_mode_set set; 567 uint32_t __user *set_connectors_ptr; 568 struct drm_modeset_acquire_ctx ctx; 569 int ret; 570 int i; 571 572 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 573 return -EINVAL; 574 575 /* 576 * Universal plane src offsets are only 16.16, prevent havoc for 577 * drivers using universal plane code internally. 578 */ 579 if (crtc_req->x & 0xffff0000 || crtc_req->y & 0xffff0000) 580 return -ERANGE; 581 582 crtc = drm_crtc_find(dev, file_priv, crtc_req->crtc_id); 583 if (!crtc) { 584 DRM_DEBUG_KMS("Unknown CRTC ID %d\n", crtc_req->crtc_id); 585 return -ENOENT; 586 } 587 DRM_DEBUG_KMS("[CRTC:%d:%s]\n", crtc->base.id, crtc->name); 588 589 plane = crtc->primary; 590 591 mutex_lock(&crtc->dev->mode_config.mutex); 592 drm_modeset_acquire_init(&ctx, DRM_MODESET_ACQUIRE_INTERRUPTIBLE); 593 retry: 594 ret = drm_modeset_lock_all_ctx(crtc->dev, &ctx); 595 if (ret) 596 goto out; 597 598 if (crtc_req->mode_valid) { 599 /* If we have a mode we need a framebuffer. */ 600 /* If we pass -1, set the mode with the currently bound fb */ 601 if (crtc_req->fb_id == -1) { 602 struct drm_framebuffer *old_fb; 603 604 if (plane->state) 605 old_fb = plane->state->fb; 606 else 607 old_fb = plane->fb; 608 609 if (!old_fb) { 610 DRM_DEBUG_KMS("CRTC doesn't have current FB\n"); 611 ret = -EINVAL; 612 goto out; 613 } 614 615 fb = old_fb; 616 /* Make refcounting symmetric with the lookup path. */ 617 drm_framebuffer_get(fb); 618 } else { 619 fb = drm_framebuffer_lookup(dev, file_priv, crtc_req->fb_id); 620 if (!fb) { 621 DRM_DEBUG_KMS("Unknown FB ID%d\n", 622 crtc_req->fb_id); 623 ret = -ENOENT; 624 goto out; 625 } 626 } 627 628 mode = drm_mode_create(dev); 629 if (!mode) { 630 ret = -ENOMEM; 631 goto out; 632 } 633 if (!file_priv->aspect_ratio_allowed && 634 (crtc_req->mode.flags & DRM_MODE_FLAG_PIC_AR_MASK) != DRM_MODE_FLAG_PIC_AR_NONE) { 635 DRM_DEBUG_KMS("Unexpected aspect-ratio flag bits\n"); 636 ret = -EINVAL; 637 goto out; 638 } 639 640 641 ret = drm_mode_convert_umode(dev, mode, &crtc_req->mode); 642 if (ret) { 643 DRM_DEBUG_KMS("Invalid mode\n"); 644 goto out; 645 } 646 647 /* 648 * Check whether the primary plane supports the fb pixel format. 649 * Drivers not implementing the universal planes API use a 650 * default formats list provided by the DRM core which doesn't 651 * match real hardware capabilities. Skip the check in that 652 * case. 653 */ 654 if (!plane->format_default) { 655 ret = drm_plane_check_pixel_format(plane, 656 fb->format->format, 657 fb->modifier); 658 if (ret) { 659 struct drm_format_name_buf format_name; 660 DRM_DEBUG_KMS("Invalid pixel format %s, modifier 0x%llx\n", 661 drm_get_format_name(fb->format->format, 662 &format_name), 663 fb->modifier); 664 goto out; 665 } 666 } 667 668 ret = drm_crtc_check_viewport(crtc, crtc_req->x, crtc_req->y, 669 mode, fb); 670 if (ret) 671 goto out; 672 673 } 674 675 if (crtc_req->count_connectors == 0 && mode) { 676 DRM_DEBUG_KMS("Count connectors is 0 but mode set\n"); 677 ret = -EINVAL; 678 goto out; 679 } 680 681 if (crtc_req->count_connectors > 0 && (!mode || !fb)) { 682 DRM_DEBUG_KMS("Count connectors is %d but no mode or fb set\n", 683 crtc_req->count_connectors); 684 ret = -EINVAL; 685 goto out; 686 } 687 688 if (crtc_req->count_connectors > 0) { 689 u32 out_id; 690 691 /* Avoid unbounded kernel memory allocation */ 692 if (crtc_req->count_connectors > config->num_connector) { 693 ret = -EINVAL; 694 goto out; 695 } 696 697 connector_set = kmalloc_array(crtc_req->count_connectors, 698 sizeof(struct drm_connector *), 699 GFP_KERNEL); 700 if (!connector_set) { 701 ret = -ENOMEM; 702 goto out; 703 } 704 705 for (i = 0; i < crtc_req->count_connectors; i++) { 706 connector_set[i] = NULL; 707 set_connectors_ptr = (uint32_t __user *)(unsigned long)crtc_req->set_connectors_ptr; 708 if (get_user(out_id, &set_connectors_ptr[i])) { 709 ret = -EFAULT; 710 goto out; 711 } 712 713 connector = drm_connector_lookup(dev, file_priv, out_id); 714 if (!connector) { 715 DRM_DEBUG_KMS("Connector id %d unknown\n", 716 out_id); 717 ret = -ENOENT; 718 goto out; 719 } 720 DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n", 721 connector->base.id, 722 connector->name); 723 724 connector_set[i] = connector; 725 } 726 } 727 728 set.crtc = crtc; 729 set.x = crtc_req->x; 730 set.y = crtc_req->y; 731 set.mode = mode; 732 set.connectors = connector_set; 733 set.num_connectors = crtc_req->count_connectors; 734 set.fb = fb; 735 ret = __drm_mode_set_config_internal(&set, &ctx); 736 737 out: 738 if (fb) 739 drm_framebuffer_put(fb); 740 741 if (connector_set) { 742 for (i = 0; i < crtc_req->count_connectors; i++) { 743 if (connector_set[i]) 744 drm_connector_put(connector_set[i]); 745 } 746 } 747 kfree(connector_set); 748 drm_mode_destroy(dev, mode); 749 if (ret == -EDEADLK) { 750 ret = drm_modeset_backoff(&ctx); 751 if (!ret) 752 goto retry; 753 } 754 drm_modeset_drop_locks(&ctx); 755 drm_modeset_acquire_fini(&ctx); 756 mutex_unlock(&crtc->dev->mode_config.mutex); 757 758 return ret; 759 } 760 761 int drm_mode_crtc_set_obj_prop(struct drm_mode_object *obj, 762 struct drm_property *property, 763 uint64_t value) 764 { 765 int ret = -EINVAL; 766 struct drm_crtc *crtc = obj_to_crtc(obj); 767 768 if (crtc->funcs->set_property) 769 ret = crtc->funcs->set_property(crtc, property, value); 770 if (!ret) 771 drm_object_property_set_value(obj, property, value); 772 773 return ret; 774 } 775