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