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->dev = dev; 286 crtc->funcs = funcs; 287 288 INIT_LIST_HEAD(&crtc->commit_list); 289 lockinit(&crtc->commit_lock, "dccl", 0, 0); 290 291 drm_modeset_lock_init(&crtc->mutex); 292 ret = drm_mode_object_add(dev, &crtc->base, DRM_MODE_OBJECT_CRTC); 293 if (ret) 294 return ret; 295 296 if (name) { 297 va_list ap; 298 299 va_start(ap, name); 300 crtc->name = kvasprintf(GFP_KERNEL, name, ap); 301 va_end(ap); 302 } else { 303 crtc->name = kasprintf(GFP_KERNEL, "crtc-%d", 304 drm_num_crtcs(dev)); 305 } 306 if (!crtc->name) { 307 drm_mode_object_unregister(dev, &crtc->base); 308 return -ENOMEM; 309 } 310 311 crtc->fence_context = dma_fence_context_alloc(1); 312 lockinit(&crtc->fence_lock, "drmcfl", 0, 0); 313 snprintf(crtc->timeline_name, sizeof(crtc->timeline_name), 314 "CRTC:%d-%s", crtc->base.id, crtc->name); 315 316 crtc->base.properties = &crtc->properties; 317 318 list_add_tail(&crtc->head, &config->crtc_list); 319 crtc->index = config->num_crtc++; 320 321 crtc->primary = primary; 322 crtc->cursor = cursor; 323 if (primary && !primary->possible_crtcs) 324 primary->possible_crtcs = 1 << drm_crtc_index(crtc); 325 if (cursor && !cursor->possible_crtcs) 326 cursor->possible_crtcs = 1 << drm_crtc_index(crtc); 327 328 ret = drm_crtc_crc_init(crtc); 329 if (ret) { 330 drm_mode_object_unregister(dev, &crtc->base); 331 return ret; 332 } 333 334 if (drm_core_check_feature(dev, DRIVER_ATOMIC)) { 335 drm_object_attach_property(&crtc->base, config->prop_active, 0); 336 drm_object_attach_property(&crtc->base, config->prop_mode_id, 0); 337 drm_object_attach_property(&crtc->base, 338 config->prop_out_fence_ptr, 0); 339 } 340 341 return 0; 342 } 343 EXPORT_SYMBOL(drm_crtc_init_with_planes); 344 345 /** 346 * drm_crtc_cleanup - Clean up the core crtc usage 347 * @crtc: CRTC to cleanup 348 * 349 * This function cleans up @crtc and removes it from the DRM mode setting 350 * core. Note that the function does *not* free the crtc structure itself, 351 * this is the responsibility of the caller. 352 */ 353 void drm_crtc_cleanup(struct drm_crtc *crtc) 354 { 355 struct drm_device *dev = crtc->dev; 356 357 /* Note that the crtc_list is considered to be static; should we 358 * remove the drm_crtc at runtime we would have to decrement all 359 * the indices on the drm_crtc after us in the crtc_list. 360 */ 361 362 drm_crtc_crc_fini(crtc); 363 364 kfree(crtc->gamma_store); 365 crtc->gamma_store = NULL; 366 367 drm_modeset_lock_fini(&crtc->mutex); 368 369 drm_mode_object_unregister(dev, &crtc->base); 370 list_del(&crtc->head); 371 dev->mode_config.num_crtc--; 372 373 WARN_ON(crtc->state && !crtc->funcs->atomic_destroy_state); 374 if (crtc->state && crtc->funcs->atomic_destroy_state) 375 crtc->funcs->atomic_destroy_state(crtc, crtc->state); 376 377 kfree(crtc->name); 378 379 memset(crtc, 0, sizeof(*crtc)); 380 } 381 EXPORT_SYMBOL(drm_crtc_cleanup); 382 383 /** 384 * drm_connector_index - find the index of a registered connector 385 * @connector: connector to find index for 386 * 387 * Given a registered connector, return the index of that connector within a DRM 388 * device's list of connectors. 389 */ 390 unsigned int drm_connector_index(struct drm_connector *connector) 391 { 392 unsigned int index = 0; 393 struct drm_connector *tmp; 394 struct drm_mode_config *config = &connector->dev->mode_config; 395 struct drm_connector_list_iter conn_iter; 396 397 WARN_ON(!drm_modeset_is_locked(&config->connection_mutex)); 398 399 drm_connector_list_iter_begin(connector->dev, &conn_iter); 400 drm_for_each_connector_iter(tmp, &conn_iter) { 401 if (tmp == connector) { 402 drm_connector_list_iter_end(&conn_iter); 403 return index; 404 } 405 406 index++; 407 } 408 drm_connector_list_iter_end(&conn_iter); 409 410 BUG(); 411 } 412 EXPORT_SYMBOL(drm_connector_index); 413 414 /** 415 * drm_mode_getcrtc - get CRTC configuration 416 * @dev: drm device for the ioctl 417 * @data: data pointer for the ioctl 418 * @file_priv: drm file for the ioctl call 419 * 420 * Construct a CRTC configuration structure to return to the user. 421 * 422 * Called by the user via ioctl. 423 * 424 * Returns: 425 * Zero on success, negative errno on failure. 426 */ 427 int drm_mode_getcrtc(struct drm_device *dev, 428 void *data, struct drm_file *file_priv) 429 { 430 struct drm_mode_crtc *crtc_resp = data; 431 struct drm_crtc *crtc; 432 433 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 434 return -EINVAL; 435 436 crtc = drm_crtc_find(dev, file_priv, crtc_resp->crtc_id); 437 if (!crtc) 438 return -ENOENT; 439 440 crtc_resp->gamma_size = crtc->gamma_size; 441 442 drm_modeset_lock(&crtc->primary->mutex, NULL); 443 if (crtc->primary->state && crtc->primary->state->fb) 444 crtc_resp->fb_id = crtc->primary->state->fb->base.id; 445 else if (!crtc->primary->state && crtc->primary->fb) 446 crtc_resp->fb_id = crtc->primary->fb->base.id; 447 else 448 crtc_resp->fb_id = 0; 449 450 if (crtc->primary->state) { 451 crtc_resp->x = crtc->primary->state->src_x >> 16; 452 crtc_resp->y = crtc->primary->state->src_y >> 16; 453 } 454 drm_modeset_unlock(&crtc->primary->mutex); 455 456 drm_modeset_lock(&crtc->mutex, NULL); 457 if (crtc->state) { 458 if (crtc->state->enable) { 459 drm_mode_convert_to_umode(&crtc_resp->mode, &crtc->state->mode); 460 crtc_resp->mode_valid = 1; 461 462 } else { 463 crtc_resp->mode_valid = 0; 464 } 465 } else { 466 crtc_resp->x = crtc->x; 467 crtc_resp->y = crtc->y; 468 if (crtc->enabled) { 469 drm_mode_convert_to_umode(&crtc_resp->mode, &crtc->mode); 470 crtc_resp->mode_valid = 1; 471 472 } else { 473 crtc_resp->mode_valid = 0; 474 } 475 } 476 drm_modeset_unlock(&crtc->mutex); 477 478 return 0; 479 } 480 481 static int __drm_mode_set_config_internal(struct drm_mode_set *set, 482 struct drm_modeset_acquire_ctx *ctx) 483 { 484 struct drm_crtc *crtc = set->crtc; 485 struct drm_framebuffer *fb; 486 struct drm_crtc *tmp; 487 int ret; 488 489 /* 490 * NOTE: ->set_config can also disable other crtcs (if we steal all 491 * connectors from it), hence we need to refcount the fbs across all 492 * crtcs. Atomic modeset will have saner semantics ... 493 */ 494 drm_for_each_crtc(tmp, crtc->dev) 495 tmp->primary->old_fb = tmp->primary->fb; 496 497 fb = set->fb; 498 499 ret = crtc->funcs->set_config(set, ctx); 500 if (ret == 0) { 501 crtc->primary->crtc = crtc; 502 crtc->primary->fb = fb; 503 } 504 505 drm_for_each_crtc(tmp, crtc->dev) { 506 if (tmp->primary->fb) 507 drm_framebuffer_get(tmp->primary->fb); 508 if (tmp->primary->old_fb) 509 drm_framebuffer_put(tmp->primary->old_fb); 510 tmp->primary->old_fb = NULL; 511 } 512 513 return ret; 514 } 515 /** 516 * drm_mode_set_config_internal - helper to call &drm_mode_config_funcs.set_config 517 * @set: modeset config to set 518 * 519 * This is a little helper to wrap internal calls to the 520 * &drm_mode_config_funcs.set_config driver interface. The only thing it adds is 521 * correct refcounting dance. 522 * 523 * This should only be used by non-atomic legacy drivers. 524 * 525 * Returns: 526 * Zero on success, negative errno on failure. 527 */ 528 int drm_mode_set_config_internal(struct drm_mode_set *set) 529 { 530 WARN_ON(drm_drv_uses_atomic_modeset(set->crtc->dev)); 531 532 return __drm_mode_set_config_internal(set, NULL); 533 } 534 EXPORT_SYMBOL(drm_mode_set_config_internal); 535 536 /** 537 * drm_crtc_check_viewport - Checks that a framebuffer is big enough for the 538 * CRTC viewport 539 * @crtc: CRTC that framebuffer will be displayed on 540 * @x: x panning 541 * @y: y panning 542 * @mode: mode that framebuffer will be displayed under 543 * @fb: framebuffer to check size of 544 */ 545 int drm_crtc_check_viewport(const struct drm_crtc *crtc, 546 int x, int y, 547 const struct drm_display_mode *mode, 548 const struct drm_framebuffer *fb) 549 550 { 551 int hdisplay, vdisplay; 552 553 drm_mode_get_hv_timing(mode, &hdisplay, &vdisplay); 554 555 if (crtc->state && 556 drm_rotation_90_or_270(crtc->primary->state->rotation)) 557 swap(hdisplay, vdisplay); 558 559 return drm_framebuffer_check_src_coords(x << 16, y << 16, 560 hdisplay << 16, vdisplay << 16, 561 fb); 562 } 563 EXPORT_SYMBOL(drm_crtc_check_viewport); 564 565 /** 566 * drm_mode_setcrtc - set CRTC configuration 567 * @dev: drm device for the ioctl 568 * @data: data pointer for the ioctl 569 * @file_priv: drm file for the ioctl call 570 * 571 * Build a new CRTC configuration based on user request. 572 * 573 * Called by the user via ioctl. 574 * 575 * Returns: 576 * Zero on success, negative errno on failure. 577 */ 578 int drm_mode_setcrtc(struct drm_device *dev, void *data, 579 struct drm_file *file_priv) 580 { 581 struct drm_mode_config *config = &dev->mode_config; 582 struct drm_mode_crtc *crtc_req = data; 583 struct drm_crtc *crtc; 584 struct drm_connector **connector_set = NULL, *connector; 585 struct drm_framebuffer *fb = NULL; 586 struct drm_display_mode *mode = NULL; 587 struct drm_mode_set set; 588 uint32_t __user *set_connectors_ptr; 589 struct drm_modeset_acquire_ctx ctx; 590 int ret; 591 int i; 592 593 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 594 return -EINVAL; 595 596 /* 597 * Universal plane src offsets are only 16.16, prevent havoc for 598 * drivers using universal plane code internally. 599 */ 600 if (crtc_req->x & 0xffff0000 || crtc_req->y & 0xffff0000) 601 return -ERANGE; 602 603 crtc = drm_crtc_find(dev, file_priv, crtc_req->crtc_id); 604 if (!crtc) { 605 DRM_DEBUG_KMS("Unknown CRTC ID %d\n", crtc_req->crtc_id); 606 return -ENOENT; 607 } 608 DRM_DEBUG_KMS("[CRTC:%d:%s]\n", crtc->base.id, crtc->name); 609 610 mutex_lock(&crtc->dev->mode_config.mutex); 611 drm_modeset_acquire_init(&ctx, DRM_MODESET_ACQUIRE_INTERRUPTIBLE); 612 retry: 613 ret = drm_modeset_lock_all_ctx(crtc->dev, &ctx); 614 if (ret) 615 goto out; 616 if (crtc_req->mode_valid) { 617 /* If we have a mode we need a framebuffer. */ 618 /* If we pass -1, set the mode with the currently bound fb */ 619 if (crtc_req->fb_id == -1) { 620 if (!crtc->primary->fb) { 621 DRM_DEBUG_KMS("CRTC doesn't have current FB\n"); 622 ret = -EINVAL; 623 goto out; 624 } 625 fb = crtc->primary->fb; 626 /* Make refcounting symmetric with the lookup path. */ 627 drm_framebuffer_get(fb); 628 } else { 629 fb = drm_framebuffer_lookup(dev, file_priv, crtc_req->fb_id); 630 if (!fb) { 631 DRM_DEBUG_KMS("Unknown FB ID%d\n", 632 crtc_req->fb_id); 633 ret = -ENOENT; 634 goto out; 635 } 636 } 637 638 mode = drm_mode_create(dev); 639 if (!mode) { 640 ret = -ENOMEM; 641 goto out; 642 } 643 644 ret = drm_mode_convert_umode(mode, &crtc_req->mode); 645 if (ret) { 646 DRM_DEBUG_KMS("Invalid mode\n"); 647 goto out; 648 } 649 650 /* 651 * Check whether the primary plane supports the fb pixel format. 652 * Drivers not implementing the universal planes API use a 653 * default formats list provided by the DRM core which doesn't 654 * match real hardware capabilities. Skip the check in that 655 * case. 656 */ 657 if (!crtc->primary->format_default) { 658 ret = drm_plane_check_pixel_format(crtc->primary, 659 fb->format->format); 660 if (ret) { 661 struct drm_format_name_buf format_name; 662 DRM_DEBUG_KMS("Invalid pixel format %s\n", 663 drm_get_format_name(fb->format->format, 664 &format_name)); 665 goto out; 666 } 667 } 668 669 ret = drm_crtc_check_viewport(crtc, crtc_req->x, crtc_req->y, 670 mode, fb); 671 if (ret) 672 goto out; 673 674 } 675 676 if (crtc_req->count_connectors == 0 && mode) { 677 DRM_DEBUG_KMS("Count connectors is 0 but mode set\n"); 678 ret = -EINVAL; 679 goto out; 680 } 681 682 if (crtc_req->count_connectors > 0 && (!mode || !fb)) { 683 DRM_DEBUG_KMS("Count connectors is %d but no mode or fb set\n", 684 crtc_req->count_connectors); 685 ret = -EINVAL; 686 goto out; 687 } 688 689 if (crtc_req->count_connectors > 0) { 690 u32 out_id; 691 692 /* Avoid unbounded kernel memory allocation */ 693 if (crtc_req->count_connectors > config->num_connector) { 694 ret = -EINVAL; 695 goto out; 696 } 697 698 connector_set = kmalloc_array(crtc_req->count_connectors, 699 sizeof(struct drm_connector *), 700 GFP_KERNEL); 701 if (!connector_set) { 702 ret = -ENOMEM; 703 goto out; 704 } 705 706 for (i = 0; i < crtc_req->count_connectors; i++) { 707 connector_set[i] = NULL; 708 set_connectors_ptr = (uint32_t __user *)(unsigned long)crtc_req->set_connectors_ptr; 709 if (get_user(out_id, &set_connectors_ptr[i])) { 710 ret = -EFAULT; 711 goto out; 712 } 713 714 connector = drm_connector_lookup(dev, file_priv, out_id); 715 if (!connector) { 716 DRM_DEBUG_KMS("Connector id %d unknown\n", 717 out_id); 718 ret = -ENOENT; 719 goto out; 720 } 721 DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n", 722 connector->base.id, 723 connector->name); 724 725 connector_set[i] = connector; 726 } 727 } 728 729 set.crtc = crtc; 730 set.x = crtc_req->x; 731 set.y = crtc_req->y; 732 set.mode = mode; 733 set.connectors = connector_set; 734 set.num_connectors = crtc_req->count_connectors; 735 set.fb = fb; 736 ret = __drm_mode_set_config_internal(&set, &ctx); 737 738 out: 739 if (fb) 740 drm_framebuffer_put(fb); 741 742 if (connector_set) { 743 for (i = 0; i < crtc_req->count_connectors; i++) { 744 if (connector_set[i]) 745 drm_connector_put(connector_set[i]); 746 } 747 } 748 kfree(connector_set); 749 drm_mode_destroy(dev, mode); 750 if (ret == -EDEADLK) { 751 ret = drm_modeset_backoff(&ctx); 752 if (!ret) 753 goto retry; 754 } 755 drm_modeset_drop_locks(&ctx); 756 drm_modeset_acquire_fini(&ctx); 757 mutex_unlock(&crtc->dev->mode_config.mutex); 758 759 return ret; 760 } 761 762 int drm_mode_crtc_set_obj_prop(struct drm_mode_object *obj, 763 struct drm_property *property, 764 uint64_t value) 765 { 766 int ret = -EINVAL; 767 struct drm_crtc *crtc = obj_to_crtc(obj); 768 769 if (crtc->funcs->set_property) 770 ret = crtc->funcs->set_property(crtc, property, value); 771 if (!ret) 772 drm_object_property_set_value(obj, property, value); 773 774 return ret; 775 } 776