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 <drm/drmP.h> 37 #include <drm/drm_crtc.h> 38 #include <drm/drm_edid.h> 39 #include <drm/drm_fourcc.h> 40 #include <drm/drm_modeset_lock.h> 41 #include <drm/drm_atomic.h> 42 #include <drm/drm_auth.h> 43 #include <drm/drm_framebuffer.h> 44 45 #include "drm_crtc_internal.h" 46 #include "drm_internal.h" 47 48 /* 49 * Global properties 50 */ 51 static const struct drm_prop_enum_list drm_plane_type_enum_list[] = { 52 { DRM_PLANE_TYPE_OVERLAY, "Overlay" }, 53 { DRM_PLANE_TYPE_PRIMARY, "Primary" }, 54 { DRM_PLANE_TYPE_CURSOR, "Cursor" }, 55 }; 56 57 /* 58 * Optional properties 59 */ 60 /** 61 * drm_crtc_force_disable - Forcibly turn off a CRTC 62 * @crtc: CRTC to turn off 63 * 64 * Returns: 65 * Zero on success, error code on failure. 66 */ 67 int drm_crtc_force_disable(struct drm_crtc *crtc) 68 { 69 struct drm_mode_set set = { 70 .crtc = crtc, 71 }; 72 73 return drm_mode_set_config_internal(&set); 74 } 75 EXPORT_SYMBOL(drm_crtc_force_disable); 76 77 /** 78 * drm_crtc_force_disable_all - Forcibly turn off all enabled CRTCs 79 * @dev: DRM device whose CRTCs to turn off 80 * 81 * Drivers may want to call this on unload to ensure that all displays are 82 * unlit and the GPU is in a consistent, low power state. Takes modeset locks. 83 * 84 * Returns: 85 * Zero on success, error code on failure. 86 */ 87 int drm_crtc_force_disable_all(struct drm_device *dev) 88 { 89 struct drm_crtc *crtc; 90 int ret = 0; 91 92 drm_modeset_lock_all(dev); 93 drm_for_each_crtc(crtc, dev) 94 if (crtc->enabled) { 95 ret = drm_crtc_force_disable(crtc); 96 if (ret) 97 goto out; 98 } 99 out: 100 drm_modeset_unlock_all(dev); 101 return ret; 102 } 103 EXPORT_SYMBOL(drm_crtc_force_disable_all); 104 105 DEFINE_WW_CLASS(crtc_ww_class); 106 107 static unsigned int drm_num_crtcs(struct drm_device *dev) 108 { 109 unsigned int num = 0; 110 struct drm_crtc *tmp; 111 112 drm_for_each_crtc(tmp, dev) { 113 num++; 114 } 115 116 return num; 117 } 118 119 static int drm_crtc_register_all(struct drm_device *dev) 120 { 121 struct drm_crtc *crtc; 122 int ret = 0; 123 124 drm_for_each_crtc(crtc, dev) { 125 if (crtc->funcs->late_register) 126 ret = crtc->funcs->late_register(crtc); 127 if (ret) 128 return ret; 129 } 130 131 return 0; 132 } 133 134 static void drm_crtc_unregister_all(struct drm_device *dev) 135 { 136 struct drm_crtc *crtc; 137 138 drm_for_each_crtc(crtc, dev) { 139 if (crtc->funcs->early_unregister) 140 crtc->funcs->early_unregister(crtc); 141 } 142 } 143 144 /** 145 * drm_crtc_init_with_planes - Initialise a new CRTC object with 146 * specified primary and cursor planes. 147 * @dev: DRM device 148 * @crtc: CRTC object to init 149 * @primary: Primary plane for CRTC 150 * @cursor: Cursor plane for CRTC 151 * @funcs: callbacks for the new CRTC 152 * @name: printf style format string for the CRTC name, or NULL for default name 153 * 154 * Inits a new object created as base part of a driver crtc object. Drivers 155 * should use this function instead of drm_crtc_init(), which is only provided 156 * for backwards compatibility with drivers which do not yet support universal 157 * planes). For really simple hardware which has only 1 plane look at 158 * drm_simple_display_pipe_init() instead. 159 * 160 * Returns: 161 * Zero on success, error code on failure. 162 */ 163 int drm_crtc_init_with_planes(struct drm_device *dev, struct drm_crtc *crtc, 164 struct drm_plane *primary, 165 struct drm_plane *cursor, 166 const struct drm_crtc_funcs *funcs, 167 const char *name, ...) 168 { 169 struct drm_mode_config *config = &dev->mode_config; 170 int ret; 171 172 WARN_ON(primary && primary->type != DRM_PLANE_TYPE_PRIMARY); 173 WARN_ON(cursor && cursor->type != DRM_PLANE_TYPE_CURSOR); 174 175 crtc->dev = dev; 176 crtc->funcs = funcs; 177 178 INIT_LIST_HEAD(&crtc->commit_list); 179 spin_lock_init(&crtc->commit_lock); 180 181 drm_modeset_lock_init(&crtc->mutex); 182 ret = drm_mode_object_get(dev, &crtc->base, DRM_MODE_OBJECT_CRTC); 183 if (ret) 184 return ret; 185 186 if (name) { 187 va_list ap; 188 189 va_start(ap, name); 190 crtc->name = kvasprintf(GFP_KERNEL, name, ap); 191 va_end(ap); 192 } else { 193 crtc->name = kasprintf(GFP_KERNEL, "crtc-%d", 194 drm_num_crtcs(dev)); 195 } 196 if (!crtc->name) { 197 drm_mode_object_unregister(dev, &crtc->base); 198 return -ENOMEM; 199 } 200 201 crtc->base.properties = &crtc->properties; 202 203 list_add_tail(&crtc->head, &config->crtc_list); 204 crtc->index = config->num_crtc++; 205 206 crtc->primary = primary; 207 crtc->cursor = cursor; 208 if (primary) 209 primary->possible_crtcs = 1 << drm_crtc_index(crtc); 210 if (cursor) 211 cursor->possible_crtcs = 1 << drm_crtc_index(crtc); 212 213 if (drm_core_check_feature(dev, DRIVER_ATOMIC)) { 214 drm_object_attach_property(&crtc->base, config->prop_active, 0); 215 drm_object_attach_property(&crtc->base, config->prop_mode_id, 0); 216 } 217 218 return 0; 219 } 220 EXPORT_SYMBOL(drm_crtc_init_with_planes); 221 222 /** 223 * drm_crtc_cleanup - Clean up the core crtc usage 224 * @crtc: CRTC to cleanup 225 * 226 * This function cleans up @crtc and removes it from the DRM mode setting 227 * core. Note that the function does *not* free the crtc structure itself, 228 * this is the responsibility of the caller. 229 */ 230 void drm_crtc_cleanup(struct drm_crtc *crtc) 231 { 232 struct drm_device *dev = crtc->dev; 233 234 /* Note that the crtc_list is considered to be static; should we 235 * remove the drm_crtc at runtime we would have to decrement all 236 * the indices on the drm_crtc after us in the crtc_list. 237 */ 238 239 kfree(crtc->gamma_store); 240 crtc->gamma_store = NULL; 241 242 drm_modeset_lock_fini(&crtc->mutex); 243 244 drm_mode_object_unregister(dev, &crtc->base); 245 list_del(&crtc->head); 246 dev->mode_config.num_crtc--; 247 248 WARN_ON(crtc->state && !crtc->funcs->atomic_destroy_state); 249 if (crtc->state && crtc->funcs->atomic_destroy_state) 250 crtc->funcs->atomic_destroy_state(crtc, crtc->state); 251 252 kfree(crtc->name); 253 254 memset(crtc, 0, sizeof(*crtc)); 255 } 256 EXPORT_SYMBOL(drm_crtc_cleanup); 257 258 int drm_modeset_register_all(struct drm_device *dev) 259 { 260 int ret; 261 262 ret = drm_plane_register_all(dev); 263 if (ret) 264 goto err_plane; 265 266 ret = drm_crtc_register_all(dev); 267 if (ret) 268 goto err_crtc; 269 270 ret = drm_encoder_register_all(dev); 271 if (ret) 272 goto err_encoder; 273 274 ret = drm_connector_register_all(dev); 275 if (ret) 276 goto err_connector; 277 278 return 0; 279 280 err_connector: 281 drm_encoder_unregister_all(dev); 282 err_encoder: 283 drm_crtc_unregister_all(dev); 284 err_crtc: 285 drm_plane_unregister_all(dev); 286 err_plane: 287 return ret; 288 } 289 290 void drm_modeset_unregister_all(struct drm_device *dev) 291 { 292 drm_connector_unregister_all(dev); 293 drm_encoder_unregister_all(dev); 294 drm_crtc_unregister_all(dev); 295 drm_plane_unregister_all(dev); 296 } 297 298 static int drm_mode_create_standard_properties(struct drm_device *dev) 299 { 300 struct drm_property *prop; 301 int ret; 302 303 ret = drm_connector_create_standard_properties(dev); 304 if (ret) 305 return ret; 306 307 prop = drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE, 308 "type", drm_plane_type_enum_list, 309 ARRAY_SIZE(drm_plane_type_enum_list)); 310 if (!prop) 311 return -ENOMEM; 312 dev->mode_config.plane_type_property = prop; 313 314 prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC, 315 "SRC_X", 0, UINT_MAX); 316 if (!prop) 317 return -ENOMEM; 318 dev->mode_config.prop_src_x = prop; 319 320 prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC, 321 "SRC_Y", 0, UINT_MAX); 322 if (!prop) 323 return -ENOMEM; 324 dev->mode_config.prop_src_y = prop; 325 326 prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC, 327 "SRC_W", 0, UINT_MAX); 328 if (!prop) 329 return -ENOMEM; 330 dev->mode_config.prop_src_w = prop; 331 332 prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC, 333 "SRC_H", 0, UINT_MAX); 334 if (!prop) 335 return -ENOMEM; 336 dev->mode_config.prop_src_h = prop; 337 338 prop = drm_property_create_signed_range(dev, DRM_MODE_PROP_ATOMIC, 339 "CRTC_X", INT_MIN, INT_MAX); 340 if (!prop) 341 return -ENOMEM; 342 dev->mode_config.prop_crtc_x = prop; 343 344 prop = drm_property_create_signed_range(dev, DRM_MODE_PROP_ATOMIC, 345 "CRTC_Y", INT_MIN, INT_MAX); 346 if (!prop) 347 return -ENOMEM; 348 dev->mode_config.prop_crtc_y = prop; 349 350 prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC, 351 "CRTC_W", 0, INT_MAX); 352 if (!prop) 353 return -ENOMEM; 354 dev->mode_config.prop_crtc_w = prop; 355 356 prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC, 357 "CRTC_H", 0, INT_MAX); 358 if (!prop) 359 return -ENOMEM; 360 dev->mode_config.prop_crtc_h = prop; 361 362 prop = drm_property_create_object(dev, DRM_MODE_PROP_ATOMIC, 363 "FB_ID", DRM_MODE_OBJECT_FB); 364 if (!prop) 365 return -ENOMEM; 366 dev->mode_config.prop_fb_id = prop; 367 368 prop = drm_property_create_object(dev, DRM_MODE_PROP_ATOMIC, 369 "CRTC_ID", DRM_MODE_OBJECT_CRTC); 370 if (!prop) 371 return -ENOMEM; 372 dev->mode_config.prop_crtc_id = prop; 373 374 prop = drm_property_create_bool(dev, DRM_MODE_PROP_ATOMIC, 375 "ACTIVE"); 376 if (!prop) 377 return -ENOMEM; 378 dev->mode_config.prop_active = prop; 379 380 prop = drm_property_create(dev, 381 DRM_MODE_PROP_ATOMIC | DRM_MODE_PROP_BLOB, 382 "MODE_ID", 0); 383 if (!prop) 384 return -ENOMEM; 385 dev->mode_config.prop_mode_id = prop; 386 387 prop = drm_property_create(dev, 388 DRM_MODE_PROP_BLOB, 389 "DEGAMMA_LUT", 0); 390 if (!prop) 391 return -ENOMEM; 392 dev->mode_config.degamma_lut_property = prop; 393 394 prop = drm_property_create_range(dev, 395 DRM_MODE_PROP_IMMUTABLE, 396 "DEGAMMA_LUT_SIZE", 0, UINT_MAX); 397 if (!prop) 398 return -ENOMEM; 399 dev->mode_config.degamma_lut_size_property = prop; 400 401 prop = drm_property_create(dev, 402 DRM_MODE_PROP_BLOB, 403 "CTM", 0); 404 if (!prop) 405 return -ENOMEM; 406 dev->mode_config.ctm_property = prop; 407 408 prop = drm_property_create(dev, 409 DRM_MODE_PROP_BLOB, 410 "GAMMA_LUT", 0); 411 if (!prop) 412 return -ENOMEM; 413 dev->mode_config.gamma_lut_property = prop; 414 415 prop = drm_property_create_range(dev, 416 DRM_MODE_PROP_IMMUTABLE, 417 "GAMMA_LUT_SIZE", 0, UINT_MAX); 418 if (!prop) 419 return -ENOMEM; 420 dev->mode_config.gamma_lut_size_property = prop; 421 422 return 0; 423 } 424 425 /** 426 * drm_mode_getresources - get graphics configuration 427 * @dev: drm device for the ioctl 428 * @data: data pointer for the ioctl 429 * @file_priv: drm file for the ioctl call 430 * 431 * Construct a set of configuration description structures and return 432 * them to the user, including CRTC, connector and framebuffer configuration. 433 * 434 * Called by the user via ioctl. 435 * 436 * Returns: 437 * Zero on success, negative errno on failure. 438 */ 439 int drm_mode_getresources(struct drm_device *dev, void *data, 440 struct drm_file *file_priv) 441 { 442 struct drm_mode_card_res *card_res = data; 443 struct list_head *lh; 444 struct drm_framebuffer *fb; 445 struct drm_connector *connector; 446 struct drm_crtc *crtc; 447 struct drm_encoder *encoder; 448 int ret = 0; 449 int connector_count = 0; 450 int crtc_count = 0; 451 int fb_count = 0; 452 int encoder_count = 0; 453 int copied = 0; 454 uint32_t __user *fb_id; 455 uint32_t __user *crtc_id; 456 uint32_t __user *connector_id; 457 uint32_t __user *encoder_id; 458 459 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 460 return -EINVAL; 461 462 463 mutex_lock(&file_priv->fbs_lock); 464 /* 465 * For the non-control nodes we need to limit the list of resources 466 * by IDs in the group list for this node 467 */ 468 list_for_each(lh, &file_priv->fbs) 469 fb_count++; 470 471 /* handle this in 4 parts */ 472 /* FBs */ 473 if (card_res->count_fbs >= fb_count) { 474 copied = 0; 475 fb_id = (uint32_t __user *)(unsigned long)card_res->fb_id_ptr; 476 list_for_each_entry(fb, &file_priv->fbs, filp_head) { 477 if (put_user(fb->base.id, fb_id + copied)) { 478 mutex_unlock(&file_priv->fbs_lock); 479 return -EFAULT; 480 } 481 copied++; 482 } 483 } 484 card_res->count_fbs = fb_count; 485 mutex_unlock(&file_priv->fbs_lock); 486 487 /* mode_config.mutex protects the connector list against e.g. DP MST 488 * connector hot-adding. CRTC/Plane lists are invariant. */ 489 mutex_lock(&dev->mode_config.mutex); 490 drm_for_each_crtc(crtc, dev) 491 crtc_count++; 492 493 drm_for_each_connector(connector, dev) 494 connector_count++; 495 496 drm_for_each_encoder(encoder, dev) 497 encoder_count++; 498 499 card_res->max_height = dev->mode_config.max_height; 500 card_res->min_height = dev->mode_config.min_height; 501 card_res->max_width = dev->mode_config.max_width; 502 card_res->min_width = dev->mode_config.min_width; 503 504 /* CRTCs */ 505 if (card_res->count_crtcs >= crtc_count) { 506 copied = 0; 507 crtc_id = (uint32_t __user *)(unsigned long)card_res->crtc_id_ptr; 508 drm_for_each_crtc(crtc, dev) { 509 if (put_user(crtc->base.id, crtc_id + copied)) { 510 ret = -EFAULT; 511 goto out; 512 } 513 copied++; 514 } 515 } 516 card_res->count_crtcs = crtc_count; 517 518 /* Encoders */ 519 if (card_res->count_encoders >= encoder_count) { 520 copied = 0; 521 encoder_id = (uint32_t __user *)(unsigned long)card_res->encoder_id_ptr; 522 drm_for_each_encoder(encoder, dev) { 523 if (put_user(encoder->base.id, encoder_id + 524 copied)) { 525 ret = -EFAULT; 526 goto out; 527 } 528 copied++; 529 } 530 } 531 card_res->count_encoders = encoder_count; 532 533 /* Connectors */ 534 if (card_res->count_connectors >= connector_count) { 535 copied = 0; 536 connector_id = (uint32_t __user *)(unsigned long)card_res->connector_id_ptr; 537 drm_for_each_connector(connector, dev) { 538 if (put_user(connector->base.id, 539 connector_id + copied)) { 540 ret = -EFAULT; 541 goto out; 542 } 543 copied++; 544 } 545 } 546 card_res->count_connectors = connector_count; 547 548 out: 549 mutex_unlock(&dev->mode_config.mutex); 550 return ret; 551 } 552 553 /** 554 * drm_mode_getcrtc - get CRTC configuration 555 * @dev: drm device for the ioctl 556 * @data: data pointer for the ioctl 557 * @file_priv: drm file for the ioctl call 558 * 559 * Construct a CRTC configuration structure to return to the user. 560 * 561 * Called by the user via ioctl. 562 * 563 * Returns: 564 * Zero on success, negative errno on failure. 565 */ 566 int drm_mode_getcrtc(struct drm_device *dev, 567 void *data, struct drm_file *file_priv) 568 { 569 struct drm_mode_crtc *crtc_resp = data; 570 struct drm_crtc *crtc; 571 572 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 573 return -EINVAL; 574 575 crtc = drm_crtc_find(dev, crtc_resp->crtc_id); 576 if (!crtc) 577 return -ENOENT; 578 579 drm_modeset_lock_crtc(crtc, crtc->primary); 580 crtc_resp->gamma_size = crtc->gamma_size; 581 if (crtc->primary->fb) 582 crtc_resp->fb_id = crtc->primary->fb->base.id; 583 else 584 crtc_resp->fb_id = 0; 585 586 if (crtc->state) { 587 crtc_resp->x = crtc->primary->state->src_x >> 16; 588 crtc_resp->y = crtc->primary->state->src_y >> 16; 589 if (crtc->state->enable) { 590 drm_mode_convert_to_umode(&crtc_resp->mode, &crtc->state->mode); 591 crtc_resp->mode_valid = 1; 592 593 } else { 594 crtc_resp->mode_valid = 0; 595 } 596 } else { 597 crtc_resp->x = crtc->x; 598 crtc_resp->y = crtc->y; 599 if (crtc->enabled) { 600 drm_mode_convert_to_umode(&crtc_resp->mode, &crtc->mode); 601 crtc_resp->mode_valid = 1; 602 603 } else { 604 crtc_resp->mode_valid = 0; 605 } 606 } 607 drm_modeset_unlock_crtc(crtc); 608 609 return 0; 610 } 611 612 /** 613 * drm_mode_set_config_internal - helper to call ->set_config 614 * @set: modeset config to set 615 * 616 * This is a little helper to wrap internal calls to the ->set_config driver 617 * interface. The only thing it adds is correct refcounting dance. 618 * 619 * Returns: 620 * Zero on success, negative errno on failure. 621 */ 622 int drm_mode_set_config_internal(struct drm_mode_set *set) 623 { 624 struct drm_crtc *crtc = set->crtc; 625 struct drm_framebuffer *fb; 626 struct drm_crtc *tmp; 627 int ret; 628 629 /* 630 * NOTE: ->set_config can also disable other crtcs (if we steal all 631 * connectors from it), hence we need to refcount the fbs across all 632 * crtcs. Atomic modeset will have saner semantics ... 633 */ 634 drm_for_each_crtc(tmp, crtc->dev) 635 tmp->primary->old_fb = tmp->primary->fb; 636 637 fb = set->fb; 638 639 ret = crtc->funcs->set_config(set); 640 if (ret == 0) { 641 crtc->primary->crtc = crtc; 642 crtc->primary->fb = fb; 643 } 644 645 drm_for_each_crtc(tmp, crtc->dev) { 646 if (tmp->primary->fb) 647 drm_framebuffer_reference(tmp->primary->fb); 648 if (tmp->primary->old_fb) 649 drm_framebuffer_unreference(tmp->primary->old_fb); 650 tmp->primary->old_fb = NULL; 651 } 652 653 return ret; 654 } 655 EXPORT_SYMBOL(drm_mode_set_config_internal); 656 657 /** 658 * drm_crtc_get_hv_timing - Fetches hdisplay/vdisplay for given mode 659 * @mode: mode to query 660 * @hdisplay: hdisplay value to fill in 661 * @vdisplay: vdisplay value to fill in 662 * 663 * The vdisplay value will be doubled if the specified mode is a stereo mode of 664 * the appropriate layout. 665 */ 666 void drm_crtc_get_hv_timing(const struct drm_display_mode *mode, 667 int *hdisplay, int *vdisplay) 668 { 669 struct drm_display_mode adjusted; 670 671 drm_mode_copy(&adjusted, mode); 672 drm_mode_set_crtcinfo(&adjusted, CRTC_STEREO_DOUBLE_ONLY); 673 *hdisplay = adjusted.crtc_hdisplay; 674 *vdisplay = adjusted.crtc_vdisplay; 675 } 676 EXPORT_SYMBOL(drm_crtc_get_hv_timing); 677 678 /** 679 * drm_crtc_check_viewport - Checks that a framebuffer is big enough for the 680 * CRTC viewport 681 * @crtc: CRTC that framebuffer will be displayed on 682 * @x: x panning 683 * @y: y panning 684 * @mode: mode that framebuffer will be displayed under 685 * @fb: framebuffer to check size of 686 */ 687 int drm_crtc_check_viewport(const struct drm_crtc *crtc, 688 int x, int y, 689 const struct drm_display_mode *mode, 690 const struct drm_framebuffer *fb) 691 692 { 693 int hdisplay, vdisplay; 694 695 drm_crtc_get_hv_timing(mode, &hdisplay, &vdisplay); 696 697 if (crtc->state && 698 crtc->primary->state->rotation & (DRM_ROTATE_90 | 699 DRM_ROTATE_270)) 700 swap(hdisplay, vdisplay); 701 702 return drm_framebuffer_check_src_coords(x << 16, y << 16, 703 hdisplay << 16, vdisplay << 16, 704 fb); 705 } 706 EXPORT_SYMBOL(drm_crtc_check_viewport); 707 708 /** 709 * drm_mode_setcrtc - set CRTC configuration 710 * @dev: drm device for the ioctl 711 * @data: data pointer for the ioctl 712 * @file_priv: drm file for the ioctl call 713 * 714 * Build a new CRTC configuration based on user request. 715 * 716 * Called by the user via ioctl. 717 * 718 * Returns: 719 * Zero on success, negative errno on failure. 720 */ 721 int drm_mode_setcrtc(struct drm_device *dev, void *data, 722 struct drm_file *file_priv) 723 { 724 struct drm_mode_config *config = &dev->mode_config; 725 struct drm_mode_crtc *crtc_req = data; 726 struct drm_crtc *crtc; 727 struct drm_connector **connector_set = NULL, *connector; 728 struct drm_framebuffer *fb = NULL; 729 struct drm_display_mode *mode = NULL; 730 struct drm_mode_set set; 731 uint32_t __user *set_connectors_ptr; 732 int ret; 733 int i; 734 735 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 736 return -EINVAL; 737 738 /* 739 * Universal plane src offsets are only 16.16, prevent havoc for 740 * drivers using universal plane code internally. 741 */ 742 if (crtc_req->x & 0xffff0000 || crtc_req->y & 0xffff0000) 743 return -ERANGE; 744 745 drm_modeset_lock_all(dev); 746 crtc = drm_crtc_find(dev, crtc_req->crtc_id); 747 if (!crtc) { 748 DRM_DEBUG_KMS("Unknown CRTC ID %d\n", crtc_req->crtc_id); 749 ret = -ENOENT; 750 goto out; 751 } 752 DRM_DEBUG_KMS("[CRTC:%d:%s]\n", crtc->base.id, crtc->name); 753 754 if (crtc_req->mode_valid) { 755 /* If we have a mode we need a framebuffer. */ 756 /* If we pass -1, set the mode with the currently bound fb */ 757 if (crtc_req->fb_id == -1) { 758 if (!crtc->primary->fb) { 759 DRM_DEBUG_KMS("CRTC doesn't have current FB\n"); 760 ret = -EINVAL; 761 goto out; 762 } 763 fb = crtc->primary->fb; 764 /* Make refcounting symmetric with the lookup path. */ 765 drm_framebuffer_reference(fb); 766 } else { 767 fb = drm_framebuffer_lookup(dev, crtc_req->fb_id); 768 if (!fb) { 769 DRM_DEBUG_KMS("Unknown FB ID%d\n", 770 crtc_req->fb_id); 771 ret = -ENOENT; 772 goto out; 773 } 774 } 775 776 mode = drm_mode_create(dev); 777 if (!mode) { 778 ret = -ENOMEM; 779 goto out; 780 } 781 782 ret = drm_mode_convert_umode(mode, &crtc_req->mode); 783 if (ret) { 784 DRM_DEBUG_KMS("Invalid mode\n"); 785 goto out; 786 } 787 788 /* 789 * Check whether the primary plane supports the fb pixel format. 790 * Drivers not implementing the universal planes API use a 791 * default formats list provided by the DRM core which doesn't 792 * match real hardware capabilities. Skip the check in that 793 * case. 794 */ 795 if (!crtc->primary->format_default) { 796 ret = drm_plane_check_pixel_format(crtc->primary, 797 fb->pixel_format); 798 if (ret) { 799 char *format_name = drm_get_format_name(fb->pixel_format); 800 DRM_DEBUG_KMS("Invalid pixel format %s\n", format_name); 801 kfree(format_name); 802 goto out; 803 } 804 } 805 806 ret = drm_crtc_check_viewport(crtc, crtc_req->x, crtc_req->y, 807 mode, fb); 808 if (ret) 809 goto out; 810 811 } 812 813 if (crtc_req->count_connectors == 0 && mode) { 814 DRM_DEBUG_KMS("Count connectors is 0 but mode set\n"); 815 ret = -EINVAL; 816 goto out; 817 } 818 819 if (crtc_req->count_connectors > 0 && (!mode || !fb)) { 820 DRM_DEBUG_KMS("Count connectors is %d but no mode or fb set\n", 821 crtc_req->count_connectors); 822 ret = -EINVAL; 823 goto out; 824 } 825 826 if (crtc_req->count_connectors > 0) { 827 u32 out_id; 828 829 /* Avoid unbounded kernel memory allocation */ 830 if (crtc_req->count_connectors > config->num_connector) { 831 ret = -EINVAL; 832 goto out; 833 } 834 835 connector_set = kmalloc_array(crtc_req->count_connectors, 836 sizeof(struct drm_connector *), 837 GFP_KERNEL); 838 if (!connector_set) { 839 ret = -ENOMEM; 840 goto out; 841 } 842 843 for (i = 0; i < crtc_req->count_connectors; i++) { 844 connector_set[i] = NULL; 845 set_connectors_ptr = (uint32_t __user *)(unsigned long)crtc_req->set_connectors_ptr; 846 if (get_user(out_id, &set_connectors_ptr[i])) { 847 ret = -EFAULT; 848 goto out; 849 } 850 851 connector = drm_connector_lookup(dev, out_id); 852 if (!connector) { 853 DRM_DEBUG_KMS("Connector id %d unknown\n", 854 out_id); 855 ret = -ENOENT; 856 goto out; 857 } 858 DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n", 859 connector->base.id, 860 connector->name); 861 862 connector_set[i] = connector; 863 } 864 } 865 866 set.crtc = crtc; 867 set.x = crtc_req->x; 868 set.y = crtc_req->y; 869 set.mode = mode; 870 set.connectors = connector_set; 871 set.num_connectors = crtc_req->count_connectors; 872 set.fb = fb; 873 ret = drm_mode_set_config_internal(&set); 874 875 out: 876 if (fb) 877 drm_framebuffer_unreference(fb); 878 879 if (connector_set) { 880 for (i = 0; i < crtc_req->count_connectors; i++) { 881 if (connector_set[i]) 882 drm_connector_unreference(connector_set[i]); 883 } 884 } 885 kfree(connector_set); 886 drm_mode_destroy(dev, mode); 887 drm_modeset_unlock_all(dev); 888 return ret; 889 } 890 891 int drm_mode_crtc_set_obj_prop(struct drm_mode_object *obj, 892 struct drm_property *property, 893 uint64_t value) 894 { 895 int ret = -EINVAL; 896 struct drm_crtc *crtc = obj_to_crtc(obj); 897 898 if (crtc->funcs->set_property) 899 ret = crtc->funcs->set_property(crtc, property, value); 900 if (!ret) 901 drm_object_property_set_value(obj, property, value); 902 903 return ret; 904 } 905 906 /** 907 * drm_mode_config_reset - call ->reset callbacks 908 * @dev: drm device 909 * 910 * This functions calls all the crtc's, encoder's and connector's ->reset 911 * callback. Drivers can use this in e.g. their driver load or resume code to 912 * reset hardware and software state. 913 */ 914 void drm_mode_config_reset(struct drm_device *dev) 915 { 916 struct drm_crtc *crtc; 917 struct drm_plane *plane; 918 struct drm_encoder *encoder; 919 struct drm_connector *connector; 920 921 drm_for_each_plane(plane, dev) 922 if (plane->funcs->reset) 923 plane->funcs->reset(plane); 924 925 drm_for_each_crtc(crtc, dev) 926 if (crtc->funcs->reset) 927 crtc->funcs->reset(crtc); 928 929 drm_for_each_encoder(encoder, dev) 930 if (encoder->funcs->reset) 931 encoder->funcs->reset(encoder); 932 933 mutex_lock(&dev->mode_config.mutex); 934 drm_for_each_connector(connector, dev) 935 if (connector->funcs->reset) 936 connector->funcs->reset(connector); 937 mutex_unlock(&dev->mode_config.mutex); 938 } 939 EXPORT_SYMBOL(drm_mode_config_reset); 940 941 /** 942 * drm_mode_create_dumb_ioctl - create a dumb backing storage buffer 943 * @dev: DRM device 944 * @data: ioctl data 945 * @file_priv: DRM file info 946 * 947 * This creates a new dumb buffer in the driver's backing storage manager (GEM, 948 * TTM or something else entirely) and returns the resulting buffer handle. This 949 * handle can then be wrapped up into a framebuffer modeset object. 950 * 951 * Note that userspace is not allowed to use such objects for render 952 * acceleration - drivers must create their own private ioctls for such a use 953 * case. 954 * 955 * Called by the user via ioctl. 956 * 957 * Returns: 958 * Zero on success, negative errno on failure. 959 */ 960 int drm_mode_create_dumb_ioctl(struct drm_device *dev, 961 void *data, struct drm_file *file_priv) 962 { 963 struct drm_mode_create_dumb *args = data; 964 u32 cpp, stride, size; 965 966 if (!dev->driver->dumb_create) 967 return -ENOSYS; 968 if (!args->width || !args->height || !args->bpp) 969 return -EINVAL; 970 971 /* overflow checks for 32bit size calculations */ 972 /* NOTE: DIV_ROUND_UP() can overflow */ 973 cpp = DIV_ROUND_UP(args->bpp, 8); 974 if (!cpp || cpp > 0xffffffffU / args->width) 975 return -EINVAL; 976 stride = cpp * args->width; 977 if (args->height > 0xffffffffU / stride) 978 return -EINVAL; 979 980 /* test for wrap-around */ 981 size = args->height * stride; 982 if (PAGE_ALIGN(size) == 0) 983 return -EINVAL; 984 985 /* 986 * handle, pitch and size are output parameters. Zero them out to 987 * prevent drivers from accidentally using uninitialized data. Since 988 * not all existing userspace is clearing these fields properly we 989 * cannot reject IOCTL with garbage in them. 990 */ 991 args->handle = 0; 992 args->pitch = 0; 993 args->size = 0; 994 995 return dev->driver->dumb_create(file_priv, dev, args); 996 } 997 998 /** 999 * drm_mode_mmap_dumb_ioctl - create an mmap offset for a dumb backing storage buffer 1000 * @dev: DRM device 1001 * @data: ioctl data 1002 * @file_priv: DRM file info 1003 * 1004 * Allocate an offset in the drm device node's address space to be able to 1005 * memory map a dumb buffer. 1006 * 1007 * Called by the user via ioctl. 1008 * 1009 * Returns: 1010 * Zero on success, negative errno on failure. 1011 */ 1012 int drm_mode_mmap_dumb_ioctl(struct drm_device *dev, 1013 void *data, struct drm_file *file_priv) 1014 { 1015 struct drm_mode_map_dumb *args = data; 1016 1017 /* call driver ioctl to get mmap offset */ 1018 if (!dev->driver->dumb_map_offset) 1019 return -ENOSYS; 1020 1021 return dev->driver->dumb_map_offset(file_priv, dev, args->handle, &args->offset); 1022 } 1023 1024 /** 1025 * drm_mode_destroy_dumb_ioctl - destroy a dumb backing strage buffer 1026 * @dev: DRM device 1027 * @data: ioctl data 1028 * @file_priv: DRM file info 1029 * 1030 * This destroys the userspace handle for the given dumb backing storage buffer. 1031 * Since buffer objects must be reference counted in the kernel a buffer object 1032 * won't be immediately freed if a framebuffer modeset object still uses it. 1033 * 1034 * Called by the user via ioctl. 1035 * 1036 * Returns: 1037 * Zero on success, negative errno on failure. 1038 */ 1039 int drm_mode_destroy_dumb_ioctl(struct drm_device *dev, 1040 void *data, struct drm_file *file_priv) 1041 { 1042 struct drm_mode_destroy_dumb *args = data; 1043 1044 if (!dev->driver->dumb_destroy) 1045 return -ENOSYS; 1046 1047 return dev->driver->dumb_destroy(file_priv, dev, args->handle); 1048 } 1049 1050 /** 1051 * drm_mode_config_init - initialize DRM mode_configuration structure 1052 * @dev: DRM device 1053 * 1054 * Initialize @dev's mode_config structure, used for tracking the graphics 1055 * configuration of @dev. 1056 * 1057 * Since this initializes the modeset locks, no locking is possible. Which is no 1058 * problem, since this should happen single threaded at init time. It is the 1059 * driver's problem to ensure this guarantee. 1060 * 1061 */ 1062 void drm_mode_config_init(struct drm_device *dev) 1063 { 1064 mutex_init(&dev->mode_config.mutex); 1065 drm_modeset_lock_init(&dev->mode_config.connection_mutex); 1066 mutex_init(&dev->mode_config.idr_mutex); 1067 mutex_init(&dev->mode_config.fb_lock); 1068 mutex_init(&dev->mode_config.blob_lock); 1069 INIT_LIST_HEAD(&dev->mode_config.fb_list); 1070 INIT_LIST_HEAD(&dev->mode_config.crtc_list); 1071 INIT_LIST_HEAD(&dev->mode_config.connector_list); 1072 INIT_LIST_HEAD(&dev->mode_config.encoder_list); 1073 INIT_LIST_HEAD(&dev->mode_config.property_list); 1074 INIT_LIST_HEAD(&dev->mode_config.property_blob_list); 1075 INIT_LIST_HEAD(&dev->mode_config.plane_list); 1076 idr_init(&dev->mode_config.crtc_idr); 1077 idr_init(&dev->mode_config.tile_idr); 1078 ida_init(&dev->mode_config.connector_ida); 1079 1080 drm_modeset_lock_all(dev); 1081 drm_mode_create_standard_properties(dev); 1082 drm_modeset_unlock_all(dev); 1083 1084 /* Just to be sure */ 1085 dev->mode_config.num_fb = 0; 1086 dev->mode_config.num_connector = 0; 1087 dev->mode_config.num_crtc = 0; 1088 dev->mode_config.num_encoder = 0; 1089 dev->mode_config.num_overlay_plane = 0; 1090 dev->mode_config.num_total_plane = 0; 1091 } 1092 EXPORT_SYMBOL(drm_mode_config_init); 1093 1094 /** 1095 * drm_mode_config_cleanup - free up DRM mode_config info 1096 * @dev: DRM device 1097 * 1098 * Free up all the connectors and CRTCs associated with this DRM device, then 1099 * free up the framebuffers and associated buffer objects. 1100 * 1101 * Note that since this /should/ happen single-threaded at driver/device 1102 * teardown time, no locking is required. It's the driver's job to ensure that 1103 * this guarantee actually holds true. 1104 * 1105 * FIXME: cleanup any dangling user buffer objects too 1106 */ 1107 void drm_mode_config_cleanup(struct drm_device *dev) 1108 { 1109 struct drm_connector *connector, *ot; 1110 struct drm_crtc *crtc, *ct; 1111 struct drm_encoder *encoder, *enct; 1112 struct drm_framebuffer *fb, *fbt; 1113 struct drm_property *property, *pt; 1114 struct drm_property_blob *blob, *bt; 1115 struct drm_plane *plane, *plt; 1116 1117 list_for_each_entry_safe(encoder, enct, &dev->mode_config.encoder_list, 1118 head) { 1119 encoder->funcs->destroy(encoder); 1120 } 1121 1122 list_for_each_entry_safe(connector, ot, 1123 &dev->mode_config.connector_list, head) { 1124 connector->funcs->destroy(connector); 1125 } 1126 1127 list_for_each_entry_safe(property, pt, &dev->mode_config.property_list, 1128 head) { 1129 drm_property_destroy(dev, property); 1130 } 1131 1132 list_for_each_entry_safe(plane, plt, &dev->mode_config.plane_list, 1133 head) { 1134 plane->funcs->destroy(plane); 1135 } 1136 1137 list_for_each_entry_safe(crtc, ct, &dev->mode_config.crtc_list, head) { 1138 crtc->funcs->destroy(crtc); 1139 } 1140 1141 list_for_each_entry_safe(blob, bt, &dev->mode_config.property_blob_list, 1142 head_global) { 1143 drm_property_unreference_blob(blob); 1144 } 1145 1146 /* 1147 * Single-threaded teardown context, so it's not required to grab the 1148 * fb_lock to protect against concurrent fb_list access. Contrary, it 1149 * would actually deadlock with the drm_framebuffer_cleanup function. 1150 * 1151 * Also, if there are any framebuffers left, that's a driver leak now, 1152 * so politely WARN about this. 1153 */ 1154 WARN_ON(!list_empty(&dev->mode_config.fb_list)); 1155 list_for_each_entry_safe(fb, fbt, &dev->mode_config.fb_list, head) { 1156 drm_framebuffer_free(&fb->base.refcount); 1157 } 1158 1159 ida_destroy(&dev->mode_config.connector_ida); 1160 idr_destroy(&dev->mode_config.tile_idr); 1161 idr_destroy(&dev->mode_config.crtc_idr); 1162 drm_modeset_lock_fini(&dev->mode_config.connection_mutex); 1163 } 1164 EXPORT_SYMBOL(drm_mode_config_cleanup); 1165 1166 /** 1167 * DOC: Tile group 1168 * 1169 * Tile groups are used to represent tiled monitors with a unique 1170 * integer identifier. Tiled monitors using DisplayID v1.3 have 1171 * a unique 8-byte handle, we store this in a tile group, so we 1172 * have a common identifier for all tiles in a monitor group. 1173 */ 1174 static void drm_tile_group_free(struct kref *kref) 1175 { 1176 struct drm_tile_group *tg = container_of(kref, struct drm_tile_group, refcount); 1177 struct drm_device *dev = tg->dev; 1178 mutex_lock(&dev->mode_config.idr_mutex); 1179 idr_remove(&dev->mode_config.tile_idr, tg->id); 1180 mutex_unlock(&dev->mode_config.idr_mutex); 1181 kfree(tg); 1182 } 1183 1184 /** 1185 * drm_mode_put_tile_group - drop a reference to a tile group. 1186 * @dev: DRM device 1187 * @tg: tile group to drop reference to. 1188 * 1189 * drop reference to tile group and free if 0. 1190 */ 1191 void drm_mode_put_tile_group(struct drm_device *dev, 1192 struct drm_tile_group *tg) 1193 { 1194 kref_put(&tg->refcount, drm_tile_group_free); 1195 } 1196 1197 /** 1198 * drm_mode_get_tile_group - get a reference to an existing tile group 1199 * @dev: DRM device 1200 * @topology: 8-bytes unique per monitor. 1201 * 1202 * Use the unique bytes to get a reference to an existing tile group. 1203 * 1204 * RETURNS: 1205 * tile group or NULL if not found. 1206 */ 1207 struct drm_tile_group *drm_mode_get_tile_group(struct drm_device *dev, 1208 char topology[8]) 1209 { 1210 struct drm_tile_group *tg; 1211 int id; 1212 mutex_lock(&dev->mode_config.idr_mutex); 1213 idr_for_each_entry(&dev->mode_config.tile_idr, tg, id) { 1214 if (!memcmp(tg->group_data, topology, 8)) { 1215 if (!kref_get_unless_zero(&tg->refcount)) 1216 tg = NULL; 1217 mutex_unlock(&dev->mode_config.idr_mutex); 1218 return tg; 1219 } 1220 } 1221 mutex_unlock(&dev->mode_config.idr_mutex); 1222 return NULL; 1223 } 1224 EXPORT_SYMBOL(drm_mode_get_tile_group); 1225 1226 /** 1227 * drm_mode_create_tile_group - create a tile group from a displayid description 1228 * @dev: DRM device 1229 * @topology: 8-bytes unique per monitor. 1230 * 1231 * Create a tile group for the unique monitor, and get a unique 1232 * identifier for the tile group. 1233 * 1234 * RETURNS: 1235 * new tile group or error. 1236 */ 1237 struct drm_tile_group *drm_mode_create_tile_group(struct drm_device *dev, 1238 char topology[8]) 1239 { 1240 struct drm_tile_group *tg; 1241 int ret; 1242 1243 tg = kzalloc(sizeof(*tg), GFP_KERNEL); 1244 if (!tg) 1245 return ERR_PTR(-ENOMEM); 1246 1247 kref_init(&tg->refcount); 1248 memcpy(tg->group_data, topology, 8); 1249 tg->dev = dev; 1250 1251 mutex_lock(&dev->mode_config.idr_mutex); 1252 ret = idr_alloc(&dev->mode_config.tile_idr, tg, 1, 0, GFP_KERNEL); 1253 if (ret >= 0) { 1254 tg->id = ret; 1255 } else { 1256 kfree(tg); 1257 tg = ERR_PTR(ret); 1258 } 1259 1260 mutex_unlock(&dev->mode_config.idr_mutex); 1261 return tg; 1262 } 1263 EXPORT_SYMBOL(drm_mode_create_tile_group); 1264