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 <linux/uaccess.h> 38 #include <drm/drm_blend.h> 39 #include <drm/drm_crtc.h> 40 #include <drm/drm_edid.h> 41 #include <drm/drm_fourcc.h> 42 #include <drm/drm_framebuffer.h> 43 #include <drm/drm_managed.h> 44 #include <drm/drm_modeset_lock.h> 45 #include <drm/drm_atomic.h> 46 #include <drm/drm_auth.h> 47 #include <drm/drm_debugfs_crc.h> 48 #include <drm/drm_drv.h> 49 #include <drm/drm_print.h> 50 #include <drm/drm_file.h> 51 52 #include "drm_crtc_internal.h" 53 #include "drm_internal.h" 54 55 /** 56 * DOC: overview 57 * 58 * A CRTC represents the overall display pipeline. It receives pixel data from 59 * &drm_plane and blends them together. The &drm_display_mode is also attached 60 * to the CRTC, specifying display timings. On the output side the data is fed 61 * to one or more &drm_encoder, which are then each connected to one 62 * &drm_connector. 63 * 64 * To create a CRTC, a KMS drivers allocates and zeroes an instances of 65 * &struct drm_crtc (possibly as part of a larger structure) and registers it 66 * with a call to drm_crtc_init_with_planes(). 67 * 68 * The CRTC is also the entry point for legacy modeset operations, see 69 * &drm_crtc_funcs.set_config, legacy plane operations, see 70 * &drm_crtc_funcs.page_flip and &drm_crtc_funcs.cursor_set2, and other legacy 71 * operations like &drm_crtc_funcs.gamma_set. For atomic drivers all these 72 * features are controlled through &drm_property and 73 * &drm_mode_config_funcs.atomic_check. 74 */ 75 76 /** 77 * drm_crtc_from_index - find the registered CRTC at an index 78 * @dev: DRM device 79 * @idx: index of registered CRTC to find for 80 * 81 * Given a CRTC index, return the registered CRTC from DRM device's 82 * list of CRTCs with matching index. This is the inverse of drm_crtc_index(). 83 * It's useful in the vblank callbacks (like &drm_driver.enable_vblank or 84 * &drm_driver.disable_vblank), since that still deals with indices instead 85 * of pointers to &struct drm_crtc." 86 */ 87 struct drm_crtc *drm_crtc_from_index(struct drm_device *dev, int idx) 88 { 89 struct drm_crtc *crtc; 90 91 drm_for_each_crtc(crtc, dev) 92 if (idx == crtc->index) 93 return crtc; 94 95 return NULL; 96 } 97 EXPORT_SYMBOL(drm_crtc_from_index); 98 99 int drm_crtc_force_disable(struct drm_crtc *crtc) 100 { 101 struct drm_mode_set set = { 102 .crtc = crtc, 103 }; 104 105 WARN_ON(drm_drv_uses_atomic_modeset(crtc->dev)); 106 107 return drm_mode_set_config_internal(&set); 108 } 109 110 static unsigned int drm_num_crtcs(struct drm_device *dev) 111 { 112 unsigned int num = 0; 113 struct drm_crtc *tmp; 114 115 drm_for_each_crtc(tmp, dev) { 116 num++; 117 } 118 119 return num; 120 } 121 122 int drm_crtc_register_all(struct drm_device *dev) 123 { 124 struct drm_crtc *crtc; 125 int ret = 0; 126 127 drm_for_each_crtc(crtc, dev) { 128 drm_debugfs_crtc_add(crtc); 129 130 if (crtc->funcs->late_register) 131 ret = crtc->funcs->late_register(crtc); 132 if (ret) 133 return ret; 134 } 135 136 return 0; 137 } 138 139 void drm_crtc_unregister_all(struct drm_device *dev) 140 { 141 struct drm_crtc *crtc; 142 143 drm_for_each_crtc(crtc, dev) { 144 if (crtc->funcs->early_unregister) 145 crtc->funcs->early_unregister(crtc); 146 drm_debugfs_crtc_remove(crtc); 147 } 148 } 149 150 static int drm_crtc_crc_init(struct drm_crtc *crtc) 151 { 152 #ifdef CONFIG_DEBUG_FS 153 spin_lock_init(&crtc->crc.lock); 154 init_waitqueue_head(&crtc->crc.wq); 155 crtc->crc.source = kstrdup("auto", GFP_KERNEL); 156 if (!crtc->crc.source) 157 return -ENOMEM; 158 #endif 159 return 0; 160 } 161 162 static void drm_crtc_crc_fini(struct drm_crtc *crtc) 163 { 164 #ifdef CONFIG_DEBUG_FS 165 kfree(crtc->crc.source); 166 #endif 167 } 168 169 static const struct dma_fence_ops drm_crtc_fence_ops; 170 171 static struct drm_crtc *fence_to_crtc(struct dma_fence *fence) 172 { 173 BUG_ON(fence->ops != &drm_crtc_fence_ops); 174 return container_of(fence->lock, struct drm_crtc, fence_lock); 175 } 176 177 static const char *drm_crtc_fence_get_driver_name(struct dma_fence *fence) 178 { 179 struct drm_crtc *crtc = fence_to_crtc(fence); 180 181 return crtc->dev->driver->name; 182 } 183 184 static const char *drm_crtc_fence_get_timeline_name(struct dma_fence *fence) 185 { 186 struct drm_crtc *crtc = fence_to_crtc(fence); 187 188 return crtc->timeline_name; 189 } 190 191 static const struct dma_fence_ops drm_crtc_fence_ops = { 192 .get_driver_name = drm_crtc_fence_get_driver_name, 193 .get_timeline_name = drm_crtc_fence_get_timeline_name, 194 }; 195 196 struct dma_fence *drm_crtc_create_fence(struct drm_crtc *crtc) 197 { 198 struct dma_fence *fence; 199 200 fence = kzalloc(sizeof(*fence), GFP_KERNEL); 201 if (!fence) 202 return NULL; 203 204 dma_fence_init(fence, &drm_crtc_fence_ops, &crtc->fence_lock, 205 crtc->fence_context, ++crtc->fence_seqno); 206 207 return fence; 208 } 209 210 /** 211 * DOC: standard CRTC properties 212 * 213 * DRM CRTCs have a few standardized properties: 214 * 215 * ACTIVE: 216 * Atomic property for setting the power state of the CRTC. When set to 1 217 * the CRTC will actively display content. When set to 0 the CRTC will be 218 * powered off. There is no expectation that user-space will reset CRTC 219 * resources like the mode and planes when setting ACTIVE to 0. 220 * 221 * User-space can rely on an ACTIVE change to 1 to never fail an atomic 222 * test as long as no other property has changed. If a change to ACTIVE 223 * fails an atomic test, this is a driver bug. For this reason setting 224 * ACTIVE to 0 must not release internal resources (like reserved memory 225 * bandwidth or clock generators). 226 * 227 * Note that the legacy DPMS property on connectors is internally routed 228 * to control this property for atomic drivers. 229 * MODE_ID: 230 * Atomic property for setting the CRTC display timings. The value is the 231 * ID of a blob containing the DRM mode info. To disable the CRTC, 232 * user-space must set this property to 0. 233 * 234 * Setting MODE_ID to 0 will release reserved resources for the CRTC. 235 * SCALING_FILTER: 236 * Atomic property for setting the scaling filter for CRTC scaler 237 * 238 * The value of this property can be one of the following: 239 * 240 * Default: 241 * Driver's default scaling filter 242 * Nearest Neighbor: 243 * Nearest Neighbor scaling filter 244 */ 245 246 __printf(6, 0) 247 static int __drm_crtc_init_with_planes(struct drm_device *dev, struct drm_crtc *crtc, 248 struct drm_plane *primary, 249 struct drm_plane *cursor, 250 const struct drm_crtc_funcs *funcs, 251 const char *name, va_list ap) 252 { 253 struct drm_mode_config *config = &dev->mode_config; 254 int ret; 255 256 WARN_ON(primary && primary->type != DRM_PLANE_TYPE_PRIMARY); 257 WARN_ON(cursor && cursor->type != DRM_PLANE_TYPE_CURSOR); 258 259 /* crtc index is used with 32bit bitmasks */ 260 if (WARN_ON(config->num_crtc >= 32)) 261 return -EINVAL; 262 263 WARN_ON(drm_drv_uses_atomic_modeset(dev) && 264 (!funcs->atomic_destroy_state || 265 !funcs->atomic_duplicate_state)); 266 267 crtc->dev = dev; 268 crtc->funcs = funcs; 269 270 INIT_LIST_HEAD(&crtc->commit_list); 271 spin_lock_init(&crtc->commit_lock); 272 273 drm_modeset_lock_init(&crtc->mutex); 274 ret = drm_mode_object_add(dev, &crtc->base, DRM_MODE_OBJECT_CRTC); 275 if (ret) 276 return ret; 277 278 if (name) { 279 crtc->name = kvasprintf(GFP_KERNEL, name, ap); 280 } else { 281 crtc->name = kasprintf(GFP_KERNEL, "crtc-%d", 282 drm_num_crtcs(dev)); 283 } 284 if (!crtc->name) { 285 drm_mode_object_unregister(dev, &crtc->base); 286 return -ENOMEM; 287 } 288 289 crtc->fence_context = dma_fence_context_alloc(1); 290 spin_lock_init(&crtc->fence_lock); 291 snprintf(crtc->timeline_name, sizeof(crtc->timeline_name), 292 "CRTC:%d-%s", crtc->base.id, crtc->name); 293 294 crtc->base.properties = &crtc->properties; 295 296 list_add_tail(&crtc->head, &config->crtc_list); 297 crtc->index = config->num_crtc++; 298 299 crtc->primary = primary; 300 crtc->cursor = cursor; 301 if (primary && !primary->possible_crtcs) 302 primary->possible_crtcs = drm_crtc_mask(crtc); 303 if (cursor && !cursor->possible_crtcs) 304 cursor->possible_crtcs = drm_crtc_mask(crtc); 305 306 ret = drm_crtc_crc_init(crtc); 307 if (ret) { 308 drm_mode_object_unregister(dev, &crtc->base); 309 return ret; 310 } 311 312 if (drm_core_check_feature(dev, DRIVER_ATOMIC)) { 313 drm_object_attach_property(&crtc->base, config->prop_active, 0); 314 drm_object_attach_property(&crtc->base, config->prop_mode_id, 0); 315 drm_object_attach_property(&crtc->base, 316 config->prop_out_fence_ptr, 0); 317 drm_object_attach_property(&crtc->base, 318 config->prop_vrr_enabled, 0); 319 } 320 321 return 0; 322 } 323 324 /** 325 * drm_crtc_init_with_planes - Initialise a new CRTC object with 326 * specified primary and cursor planes. 327 * @dev: DRM device 328 * @crtc: CRTC object to init 329 * @primary: Primary plane for CRTC 330 * @cursor: Cursor plane for CRTC 331 * @funcs: callbacks for the new CRTC 332 * @name: printf style format string for the CRTC name, or NULL for default name 333 * 334 * Inits a new object created as base part of a driver crtc object. Drivers 335 * should use this function instead of drm_crtc_init(), which is only provided 336 * for backwards compatibility with drivers which do not yet support universal 337 * planes). For really simple hardware which has only 1 plane look at 338 * drm_simple_display_pipe_init() instead. 339 * The &drm_crtc_funcs.destroy hook should call drm_crtc_cleanup() and kfree() 340 * the crtc structure. The crtc structure should not be allocated with 341 * devm_kzalloc(). 342 * 343 * The @primary and @cursor planes are only relevant for legacy uAPI, see 344 * &drm_crtc.primary and &drm_crtc.cursor. 345 * 346 * Note: consider using drmm_crtc_alloc_with_planes() or 347 * drmm_crtc_init_with_planes() instead of drm_crtc_init_with_planes() 348 * to let the DRM managed resource infrastructure take care of cleanup 349 * and deallocation. 350 * 351 * Returns: 352 * Zero on success, error code on failure. 353 */ 354 int drm_crtc_init_with_planes(struct drm_device *dev, struct drm_crtc *crtc, 355 struct drm_plane *primary, 356 struct drm_plane *cursor, 357 const struct drm_crtc_funcs *funcs, 358 const char *name, ...) 359 { 360 va_list ap; 361 int ret; 362 363 WARN_ON(!funcs->destroy); 364 365 va_start(ap, name); 366 ret = __drm_crtc_init_with_planes(dev, crtc, primary, cursor, funcs, 367 name, ap); 368 va_end(ap); 369 370 return ret; 371 } 372 EXPORT_SYMBOL(drm_crtc_init_with_planes); 373 374 static void drmm_crtc_init_with_planes_cleanup(struct drm_device *dev, 375 void *ptr) 376 { 377 struct drm_crtc *crtc = ptr; 378 379 drm_crtc_cleanup(crtc); 380 } 381 382 __printf(6, 0) 383 static int __drmm_crtc_init_with_planes(struct drm_device *dev, 384 struct drm_crtc *crtc, 385 struct drm_plane *primary, 386 struct drm_plane *cursor, 387 const struct drm_crtc_funcs *funcs, 388 const char *name, 389 va_list args) 390 { 391 int ret; 392 393 drm_WARN_ON(dev, funcs && funcs->destroy); 394 395 ret = __drm_crtc_init_with_planes(dev, crtc, primary, cursor, funcs, 396 name, args); 397 if (ret) 398 return ret; 399 400 ret = drmm_add_action_or_reset(dev, drmm_crtc_init_with_planes_cleanup, 401 crtc); 402 if (ret) 403 return ret; 404 405 return 0; 406 } 407 408 /** 409 * drmm_crtc_init_with_planes - Initialise a new CRTC object with 410 * specified primary and cursor planes. 411 * @dev: DRM device 412 * @crtc: CRTC object to init 413 * @primary: Primary plane for CRTC 414 * @cursor: Cursor plane for CRTC 415 * @funcs: callbacks for the new CRTC 416 * @name: printf style format string for the CRTC name, or NULL for default name 417 * 418 * Inits a new object created as base part of a driver crtc object. Drivers 419 * should use this function instead of drm_crtc_init(), which is only provided 420 * for backwards compatibility with drivers which do not yet support universal 421 * planes). For really simple hardware which has only 1 plane look at 422 * drm_simple_display_pipe_init() instead. 423 * 424 * Cleanup is automatically handled through registering 425 * drmm_crtc_cleanup() with drmm_add_action(). The crtc structure should 426 * be allocated with drmm_kzalloc(). 427 * 428 * The @drm_crtc_funcs.destroy hook must be NULL. 429 * 430 * The @primary and @cursor planes are only relevant for legacy uAPI, see 431 * &drm_crtc.primary and &drm_crtc.cursor. 432 * 433 * Returns: 434 * Zero on success, error code on failure. 435 */ 436 int drmm_crtc_init_with_planes(struct drm_device *dev, struct drm_crtc *crtc, 437 struct drm_plane *primary, 438 struct drm_plane *cursor, 439 const struct drm_crtc_funcs *funcs, 440 const char *name, ...) 441 { 442 va_list ap; 443 int ret; 444 445 va_start(ap, name); 446 ret = __drmm_crtc_init_with_planes(dev, crtc, primary, cursor, funcs, 447 name, ap); 448 va_end(ap); 449 if (ret) 450 return ret; 451 452 return 0; 453 } 454 EXPORT_SYMBOL(drmm_crtc_init_with_planes); 455 456 void *__drmm_crtc_alloc_with_planes(struct drm_device *dev, 457 size_t size, size_t offset, 458 struct drm_plane *primary, 459 struct drm_plane *cursor, 460 const struct drm_crtc_funcs *funcs, 461 const char *name, ...) 462 { 463 void *container; 464 struct drm_crtc *crtc; 465 va_list ap; 466 int ret; 467 468 if (WARN_ON(!funcs || funcs->destroy)) 469 return ERR_PTR(-EINVAL); 470 471 container = drmm_kzalloc(dev, size, GFP_KERNEL); 472 if (!container) 473 return ERR_PTR(-ENOMEM); 474 475 crtc = container + offset; 476 477 va_start(ap, name); 478 ret = __drmm_crtc_init_with_planes(dev, crtc, primary, cursor, funcs, 479 name, ap); 480 va_end(ap); 481 if (ret) 482 return ERR_PTR(ret); 483 484 return container; 485 } 486 EXPORT_SYMBOL(__drmm_crtc_alloc_with_planes); 487 488 /** 489 * drm_crtc_cleanup - Clean up the core crtc usage 490 * @crtc: CRTC to cleanup 491 * 492 * This function cleans up @crtc and removes it from the DRM mode setting 493 * core. Note that the function does *not* free the crtc structure itself, 494 * this is the responsibility of the caller. 495 */ 496 void drm_crtc_cleanup(struct drm_crtc *crtc) 497 { 498 struct drm_device *dev = crtc->dev; 499 500 /* Note that the crtc_list is considered to be static; should we 501 * remove the drm_crtc at runtime we would have to decrement all 502 * the indices on the drm_crtc after us in the crtc_list. 503 */ 504 505 drm_crtc_crc_fini(crtc); 506 507 kfree(crtc->gamma_store); 508 crtc->gamma_store = NULL; 509 510 drm_modeset_lock_fini(&crtc->mutex); 511 512 drm_mode_object_unregister(dev, &crtc->base); 513 list_del(&crtc->head); 514 dev->mode_config.num_crtc--; 515 516 WARN_ON(crtc->state && !crtc->funcs->atomic_destroy_state); 517 if (crtc->state && crtc->funcs->atomic_destroy_state) 518 crtc->funcs->atomic_destroy_state(crtc, crtc->state); 519 520 kfree(crtc->name); 521 522 memset(crtc, 0, sizeof(*crtc)); 523 } 524 EXPORT_SYMBOL(drm_crtc_cleanup); 525 526 /** 527 * drm_mode_getcrtc - get CRTC configuration 528 * @dev: drm device for the ioctl 529 * @data: data pointer for the ioctl 530 * @file_priv: drm file for the ioctl call 531 * 532 * Construct a CRTC configuration structure to return to the user. 533 * 534 * Called by the user via ioctl. 535 * 536 * Returns: 537 * Zero on success, negative errno on failure. 538 */ 539 int drm_mode_getcrtc(struct drm_device *dev, 540 void *data, struct drm_file *file_priv) 541 { 542 struct drm_mode_crtc *crtc_resp = data; 543 struct drm_crtc *crtc; 544 struct drm_plane *plane; 545 546 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 547 return -EOPNOTSUPP; 548 549 crtc = drm_crtc_find(dev, file_priv, crtc_resp->crtc_id); 550 if (!crtc) 551 return -ENOENT; 552 553 plane = crtc->primary; 554 555 crtc_resp->gamma_size = crtc->gamma_size; 556 557 drm_modeset_lock(&plane->mutex, NULL); 558 if (plane->state && plane->state->fb) 559 crtc_resp->fb_id = plane->state->fb->base.id; 560 else if (!plane->state && plane->fb) 561 crtc_resp->fb_id = plane->fb->base.id; 562 else 563 crtc_resp->fb_id = 0; 564 565 if (plane->state) { 566 crtc_resp->x = plane->state->src_x >> 16; 567 crtc_resp->y = plane->state->src_y >> 16; 568 } 569 drm_modeset_unlock(&plane->mutex); 570 571 drm_modeset_lock(&crtc->mutex, NULL); 572 if (crtc->state) { 573 if (crtc->state->enable) { 574 drm_mode_convert_to_umode(&crtc_resp->mode, &crtc->state->mode); 575 crtc_resp->mode_valid = 1; 576 } else { 577 crtc_resp->mode_valid = 0; 578 } 579 } else { 580 crtc_resp->x = crtc->x; 581 crtc_resp->y = crtc->y; 582 583 if (crtc->enabled) { 584 drm_mode_convert_to_umode(&crtc_resp->mode, &crtc->mode); 585 crtc_resp->mode_valid = 1; 586 587 } else { 588 crtc_resp->mode_valid = 0; 589 } 590 } 591 if (!file_priv->aspect_ratio_allowed) 592 crtc_resp->mode.flags &= ~DRM_MODE_FLAG_PIC_AR_MASK; 593 drm_modeset_unlock(&crtc->mutex); 594 595 return 0; 596 } 597 598 static int __drm_mode_set_config_internal(struct drm_mode_set *set, 599 struct drm_modeset_acquire_ctx *ctx) 600 { 601 struct drm_crtc *crtc = set->crtc; 602 struct drm_framebuffer *fb; 603 struct drm_crtc *tmp; 604 int ret; 605 606 WARN_ON(drm_drv_uses_atomic_modeset(crtc->dev)); 607 608 /* 609 * NOTE: ->set_config can also disable other crtcs (if we steal all 610 * connectors from it), hence we need to refcount the fbs across all 611 * crtcs. Atomic modeset will have saner semantics ... 612 */ 613 drm_for_each_crtc(tmp, crtc->dev) { 614 struct drm_plane *plane = tmp->primary; 615 616 plane->old_fb = plane->fb; 617 } 618 619 fb = set->fb; 620 621 ret = crtc->funcs->set_config(set, ctx); 622 if (ret == 0) { 623 struct drm_plane *plane = crtc->primary; 624 625 plane->crtc = fb ? crtc : NULL; 626 plane->fb = fb; 627 } 628 629 drm_for_each_crtc(tmp, crtc->dev) { 630 struct drm_plane *plane = tmp->primary; 631 632 if (plane->fb) 633 drm_framebuffer_get(plane->fb); 634 if (plane->old_fb) 635 drm_framebuffer_put(plane->old_fb); 636 plane->old_fb = NULL; 637 } 638 639 return ret; 640 } 641 642 /** 643 * drm_mode_set_config_internal - helper to call &drm_mode_config_funcs.set_config 644 * @set: modeset config to set 645 * 646 * This is a little helper to wrap internal calls to the 647 * &drm_mode_config_funcs.set_config driver interface. The only thing it adds is 648 * correct refcounting dance. 649 * 650 * This should only be used by non-atomic legacy drivers. 651 * 652 * Returns: 653 * Zero on success, negative errno on failure. 654 */ 655 int drm_mode_set_config_internal(struct drm_mode_set *set) 656 { 657 WARN_ON(drm_drv_uses_atomic_modeset(set->crtc->dev)); 658 659 return __drm_mode_set_config_internal(set, NULL); 660 } 661 EXPORT_SYMBOL(drm_mode_set_config_internal); 662 663 /** 664 * drm_crtc_check_viewport - Checks that a framebuffer is big enough for the 665 * CRTC viewport 666 * @crtc: CRTC that framebuffer will be displayed on 667 * @x: x panning 668 * @y: y panning 669 * @mode: mode that framebuffer will be displayed under 670 * @fb: framebuffer to check size of 671 */ 672 int drm_crtc_check_viewport(const struct drm_crtc *crtc, 673 int x, int y, 674 const struct drm_display_mode *mode, 675 const struct drm_framebuffer *fb) 676 677 { 678 int hdisplay, vdisplay; 679 680 drm_mode_get_hv_timing(mode, &hdisplay, &vdisplay); 681 682 if (crtc->state && 683 drm_rotation_90_or_270(crtc->primary->state->rotation)) 684 swap(hdisplay, vdisplay); 685 686 return drm_framebuffer_check_src_coords(x << 16, y << 16, 687 hdisplay << 16, vdisplay << 16, 688 fb); 689 } 690 EXPORT_SYMBOL(drm_crtc_check_viewport); 691 692 /** 693 * drm_mode_setcrtc - set CRTC configuration 694 * @dev: drm device for the ioctl 695 * @data: data pointer for the ioctl 696 * @file_priv: drm file for the ioctl call 697 * 698 * Build a new CRTC configuration based on user request. 699 * 700 * Called by the user via ioctl. 701 * 702 * Returns: 703 * Zero on success, negative errno on failure. 704 */ 705 int drm_mode_setcrtc(struct drm_device *dev, void *data, 706 struct drm_file *file_priv) 707 { 708 struct drm_mode_config *config = &dev->mode_config; 709 struct drm_mode_crtc *crtc_req = data; 710 struct drm_crtc *crtc; 711 struct drm_plane *plane; 712 struct drm_connector **connector_set = NULL, *connector; 713 struct drm_framebuffer *fb = NULL; 714 struct drm_display_mode *mode = NULL; 715 struct drm_mode_set set; 716 uint32_t __user *set_connectors_ptr; 717 struct drm_modeset_acquire_ctx ctx; 718 int ret; 719 int i; 720 721 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 722 return -EOPNOTSUPP; 723 724 /* 725 * Universal plane src offsets are only 16.16, prevent havoc for 726 * drivers using universal plane code internally. 727 */ 728 if (crtc_req->x & 0xffff0000 || crtc_req->y & 0xffff0000) 729 return -ERANGE; 730 731 crtc = drm_crtc_find(dev, file_priv, crtc_req->crtc_id); 732 if (!crtc) { 733 DRM_DEBUG_KMS("Unknown CRTC ID %d\n", crtc_req->crtc_id); 734 return -ENOENT; 735 } 736 DRM_DEBUG_KMS("[CRTC:%d:%s]\n", crtc->base.id, crtc->name); 737 738 plane = crtc->primary; 739 740 /* allow disabling with the primary plane leased */ 741 if (crtc_req->mode_valid && !drm_lease_held(file_priv, plane->base.id)) 742 return -EACCES; 743 744 DRM_MODESET_LOCK_ALL_BEGIN(dev, ctx, 745 DRM_MODESET_ACQUIRE_INTERRUPTIBLE, ret); 746 747 if (crtc_req->mode_valid) { 748 /* If we have a mode we need a framebuffer. */ 749 /* If we pass -1, set the mode with the currently bound fb */ 750 if (crtc_req->fb_id == -1) { 751 struct drm_framebuffer *old_fb; 752 753 if (plane->state) 754 old_fb = plane->state->fb; 755 else 756 old_fb = plane->fb; 757 758 if (!old_fb) { 759 DRM_DEBUG_KMS("CRTC doesn't have current FB\n"); 760 ret = -EINVAL; 761 goto out; 762 } 763 764 fb = old_fb; 765 /* Make refcounting symmetric with the lookup path. */ 766 drm_framebuffer_get(fb); 767 } else { 768 fb = drm_framebuffer_lookup(dev, file_priv, crtc_req->fb_id); 769 if (!fb) { 770 DRM_DEBUG_KMS("Unknown FB ID%d\n", 771 crtc_req->fb_id); 772 ret = -ENOENT; 773 goto out; 774 } 775 } 776 777 mode = drm_mode_create(dev); 778 if (!mode) { 779 ret = -ENOMEM; 780 goto out; 781 } 782 if (!file_priv->aspect_ratio_allowed && 783 (crtc_req->mode.flags & DRM_MODE_FLAG_PIC_AR_MASK) != DRM_MODE_FLAG_PIC_AR_NONE) { 784 DRM_DEBUG_KMS("Unexpected aspect-ratio flag bits\n"); 785 ret = -EINVAL; 786 goto out; 787 } 788 789 790 ret = drm_mode_convert_umode(dev, mode, &crtc_req->mode); 791 if (ret) { 792 DRM_DEBUG_KMS("Invalid mode (ret=%d, status=%s)\n", 793 ret, drm_get_mode_status_name(mode->status)); 794 drm_mode_debug_printmodeline(mode); 795 goto out; 796 } 797 798 /* 799 * Check whether the primary plane supports the fb pixel format. 800 * Drivers not implementing the universal planes API use a 801 * default formats list provided by the DRM core which doesn't 802 * match real hardware capabilities. Skip the check in that 803 * case. 804 */ 805 if (!plane->format_default) { 806 ret = drm_plane_check_pixel_format(plane, 807 fb->format->format, 808 fb->modifier); 809 if (ret) { 810 DRM_DEBUG_KMS("Invalid pixel format %p4cc, modifier 0x%llx\n", 811 &fb->format->format, 812 fb->modifier); 813 goto out; 814 } 815 } 816 817 ret = drm_crtc_check_viewport(crtc, crtc_req->x, crtc_req->y, 818 mode, fb); 819 if (ret) 820 goto out; 821 822 } 823 824 if (crtc_req->count_connectors == 0 && mode) { 825 DRM_DEBUG_KMS("Count connectors is 0 but mode set\n"); 826 ret = -EINVAL; 827 goto out; 828 } 829 830 if (crtc_req->count_connectors > 0 && (!mode || !fb)) { 831 DRM_DEBUG_KMS("Count connectors is %d but no mode or fb set\n", 832 crtc_req->count_connectors); 833 ret = -EINVAL; 834 goto out; 835 } 836 837 if (crtc_req->count_connectors > 0) { 838 u32 out_id; 839 840 /* Avoid unbounded kernel memory allocation */ 841 if (crtc_req->count_connectors > config->num_connector) { 842 ret = -EINVAL; 843 goto out; 844 } 845 846 connector_set = kmalloc_array(crtc_req->count_connectors, 847 sizeof(struct drm_connector *), 848 GFP_KERNEL); 849 if (!connector_set) { 850 ret = -ENOMEM; 851 goto out; 852 } 853 854 for (i = 0; i < crtc_req->count_connectors; i++) { 855 connector_set[i] = NULL; 856 set_connectors_ptr = (uint32_t __user *)(unsigned long)crtc_req->set_connectors_ptr; 857 if (get_user(out_id, &set_connectors_ptr[i])) { 858 ret = -EFAULT; 859 goto out; 860 } 861 862 connector = drm_connector_lookup(dev, file_priv, out_id); 863 if (!connector) { 864 DRM_DEBUG_KMS("Connector id %d unknown\n", 865 out_id); 866 ret = -ENOENT; 867 goto out; 868 } 869 DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n", 870 connector->base.id, 871 connector->name); 872 873 connector_set[i] = connector; 874 } 875 } 876 877 set.crtc = crtc; 878 set.x = crtc_req->x; 879 set.y = crtc_req->y; 880 set.mode = mode; 881 set.connectors = connector_set; 882 set.num_connectors = crtc_req->count_connectors; 883 set.fb = fb; 884 885 if (drm_drv_uses_atomic_modeset(dev)) 886 ret = crtc->funcs->set_config(&set, &ctx); 887 else 888 ret = __drm_mode_set_config_internal(&set, &ctx); 889 890 out: 891 if (fb) 892 drm_framebuffer_put(fb); 893 894 if (connector_set) { 895 for (i = 0; i < crtc_req->count_connectors; i++) { 896 if (connector_set[i]) 897 drm_connector_put(connector_set[i]); 898 } 899 } 900 kfree(connector_set); 901 drm_mode_destroy(dev, mode); 902 903 /* In case we need to retry... */ 904 connector_set = NULL; 905 fb = NULL; 906 mode = NULL; 907 908 DRM_MODESET_LOCK_ALL_END(dev, ctx, ret); 909 910 return ret; 911 } 912 913 int drm_mode_crtc_set_obj_prop(struct drm_mode_object *obj, 914 struct drm_property *property, 915 uint64_t value) 916 { 917 int ret = -EINVAL; 918 struct drm_crtc *crtc = obj_to_crtc(obj); 919 920 if (crtc->funcs->set_property) 921 ret = crtc->funcs->set_property(crtc, property, value); 922 if (!ret) 923 drm_object_property_set_value(obj, property, value); 924 925 return ret; 926 } 927 928 /** 929 * drm_crtc_create_scaling_filter_property - create a new scaling filter 930 * property 931 * 932 * @crtc: drm CRTC 933 * @supported_filters: bitmask of supported scaling filters, must include 934 * BIT(DRM_SCALING_FILTER_DEFAULT). 935 * 936 * This function lets driver to enable the scaling filter property on a given 937 * CRTC. 938 * 939 * RETURNS: 940 * Zero for success or -errno 941 */ 942 int drm_crtc_create_scaling_filter_property(struct drm_crtc *crtc, 943 unsigned int supported_filters) 944 { 945 struct drm_property *prop = 946 drm_create_scaling_filter_prop(crtc->dev, supported_filters); 947 948 if (IS_ERR(prop)) 949 return PTR_ERR(prop); 950 951 drm_object_attach_property(&crtc->base, prop, 952 DRM_SCALING_FILTER_DEFAULT); 953 crtc->scaling_filter_property = prop; 954 955 return 0; 956 } 957 EXPORT_SYMBOL(drm_crtc_create_scaling_filter_property); 958