1 /* 2 * Copyright (c) 2016 Intel Corporation 3 * 4 * Permission to use, copy, modify, distribute, and sell this software and its 5 * documentation for any purpose is hereby granted without fee, provided that 6 * the above copyright notice appear in all copies and that both that copyright 7 * notice and this permission notice appear in supporting documentation, and 8 * that the name of the copyright holders not be used in advertising or 9 * publicity pertaining to distribution of the software without specific, 10 * written prior permission. The copyright holders make no representations 11 * about the suitability of this software for any purpose. It is provided "as 12 * is" without express or implied warranty. 13 * 14 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, 15 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO 16 * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR 17 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, 18 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER 19 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 20 * OF THIS SOFTWARE. 21 */ 22 23 #include <drm/drmP.h> 24 #include <drm/drm_plane.h> 25 26 #include "drm_crtc_internal.h" 27 28 /** 29 * DOC: overview 30 * 31 * A plane represents an image source that can be blended with or overlayed on 32 * top of a CRTC during the scanout process. Planes take their input data from a 33 * &drm_framebuffer object. The plane itself specifies the cropping and scaling 34 * of that image, and where it is placed on the visible are of a display 35 * pipeline, represented by &drm_crtc. A plane can also have additional 36 * properties that specify how the pixels are positioned and blended, like 37 * rotation or Z-position. All these properties are stored in &drm_plane_state. 38 * 39 * To create a plane, a KMS drivers allocates and zeroes an instances of 40 * &struct drm_plane (possibly as part of a larger structure) and registers it 41 * with a call to drm_universal_plane_init(). 42 * 43 * Cursor and overlay planes are optional. All drivers should provide one 44 * primary plane per CRTC to avoid surprising userspace too much. See enum 45 * drm_plane_type for a more in-depth discussion of these special uapi-relevant 46 * plane types. Special planes are associated with their CRTC by calling 47 * drm_crtc_init_with_planes(). 48 * 49 * The type of a plane is exposed in the immutable "type" enumeration property, 50 * which has one of the following values: "Overlay", "Primary", "Cursor". 51 */ 52 53 static unsigned int drm_num_planes(struct drm_device *dev) 54 { 55 unsigned int num = 0; 56 struct drm_plane *tmp; 57 58 drm_for_each_plane(tmp, dev) { 59 num++; 60 } 61 62 return num; 63 } 64 65 static inline u32 * 66 formats_ptr(struct drm_format_modifier_blob *blob) 67 { 68 return (u32 *)(((char *)blob) + blob->formats_offset); 69 } 70 71 static inline struct drm_format_modifier * 72 modifiers_ptr(struct drm_format_modifier_blob *blob) 73 { 74 return (struct drm_format_modifier *)(((char *)blob) + blob->modifiers_offset); 75 } 76 77 static int create_in_format_blob(struct drm_device *dev, struct drm_plane *plane) 78 { 79 const struct drm_mode_config *config = &dev->mode_config; 80 struct drm_property_blob *blob; 81 struct drm_format_modifier *mod; 82 size_t blob_size, formats_size, modifiers_size; 83 struct drm_format_modifier_blob *blob_data; 84 unsigned int i, j; 85 86 formats_size = sizeof(__u32) * plane->format_count; 87 if (WARN_ON(!formats_size)) { 88 /* 0 formats are never expected */ 89 return 0; 90 } 91 92 modifiers_size = 93 sizeof(struct drm_format_modifier) * plane->modifier_count; 94 95 blob_size = sizeof(struct drm_format_modifier_blob); 96 /* Modifiers offset is a pointer to a struct with a 64 bit field so it 97 * should be naturally aligned to 8B. 98 */ 99 BUILD_BUG_ON(sizeof(struct drm_format_modifier_blob) % 8); 100 blob_size += ALIGN(formats_size, 8); 101 blob_size += modifiers_size; 102 103 blob = drm_property_create_blob(dev, blob_size, NULL); 104 if (IS_ERR(blob)) 105 return -1; 106 107 blob_data = blob->data; 108 blob_data->version = FORMAT_BLOB_CURRENT; 109 blob_data->count_formats = plane->format_count; 110 blob_data->formats_offset = sizeof(struct drm_format_modifier_blob); 111 blob_data->count_modifiers = plane->modifier_count; 112 113 blob_data->modifiers_offset = 114 ALIGN(blob_data->formats_offset + formats_size, 8); 115 116 memcpy(formats_ptr(blob_data), plane->format_types, formats_size); 117 118 /* If we can't determine support, just bail */ 119 if (!plane->funcs->format_mod_supported) 120 goto done; 121 122 mod = modifiers_ptr(blob_data); 123 for (i = 0; i < plane->modifier_count; i++) { 124 for (j = 0; j < plane->format_count; j++) { 125 if (plane->funcs->format_mod_supported(plane, 126 plane->format_types[j], 127 plane->modifiers[i])) { 128 129 mod->formats |= 1ULL << j; 130 } 131 } 132 133 mod->modifier = plane->modifiers[i]; 134 mod->offset = 0; 135 mod->pad = 0; 136 mod++; 137 } 138 139 done: 140 drm_object_attach_property(&plane->base, config->modifiers_property, 141 blob->base.id); 142 143 return 0; 144 } 145 146 /** 147 * drm_universal_plane_init - Initialize a new universal plane object 148 * @dev: DRM device 149 * @plane: plane object to init 150 * @possible_crtcs: bitmask of possible CRTCs 151 * @funcs: callbacks for the new plane 152 * @formats: array of supported formats (DRM_FORMAT\_\*) 153 * @format_count: number of elements in @formats 154 * @format_modifiers: array of struct drm_format modifiers terminated by 155 * DRM_FORMAT_MOD_INVALID 156 * @type: type of plane (overlay, primary, cursor) 157 * @name: printf style format string for the plane name, or NULL for default name 158 * 159 * Initializes a plane object of type @type. 160 * 161 * Returns: 162 * Zero on success, error code on failure. 163 */ 164 int drm_universal_plane_init(struct drm_device *dev, struct drm_plane *plane, 165 uint32_t possible_crtcs, 166 const struct drm_plane_funcs *funcs, 167 const uint32_t *formats, unsigned int format_count, 168 const uint64_t *format_modifiers, 169 enum drm_plane_type type, 170 const char *name, ...) 171 { 172 struct drm_mode_config *config = &dev->mode_config; 173 unsigned int format_modifier_count = 0; 174 int ret; 175 176 /* plane index is used with 32bit bitmasks */ 177 if (WARN_ON(config->num_total_plane >= 32)) 178 return -EINVAL; 179 180 WARN_ON(drm_drv_uses_atomic_modeset(dev) && 181 (!funcs->atomic_destroy_state || 182 !funcs->atomic_duplicate_state)); 183 184 ret = drm_mode_object_add(dev, &plane->base, DRM_MODE_OBJECT_PLANE); 185 if (ret) 186 return ret; 187 188 drm_modeset_lock_init(&plane->mutex); 189 190 plane->base.properties = &plane->properties; 191 plane->dev = dev; 192 plane->funcs = funcs; 193 plane->format_types = kmalloc_array(format_count, sizeof(uint32_t), 194 GFP_KERNEL); 195 if (!plane->format_types) { 196 DRM_DEBUG_KMS("out of memory when allocating plane\n"); 197 drm_mode_object_unregister(dev, &plane->base); 198 return -ENOMEM; 199 } 200 201 /* 202 * First driver to need more than 64 formats needs to fix this. Each 203 * format is encoded as a bit and the current code only supports a u64. 204 */ 205 if (WARN_ON(format_count > 64)) 206 return -EINVAL; 207 208 if (format_modifiers) { 209 const uint64_t *temp_modifiers = format_modifiers; 210 while (*temp_modifiers++ != DRM_FORMAT_MOD_INVALID) 211 format_modifier_count++; 212 } 213 214 plane->modifier_count = format_modifier_count; 215 plane->modifiers = kmalloc_array(format_modifier_count, 216 sizeof(format_modifiers[0]), 217 GFP_KERNEL); 218 219 if (format_modifier_count && !plane->modifiers) { 220 DRM_DEBUG_KMS("out of memory when allocating plane\n"); 221 kfree(plane->format_types); 222 drm_mode_object_unregister(dev, &plane->base); 223 return -ENOMEM; 224 } 225 226 if (name) { 227 va_list ap; 228 229 va_start(ap, name); 230 plane->name = kvasprintf(GFP_KERNEL, name, ap); 231 va_end(ap); 232 } else { 233 plane->name = kasprintf(GFP_KERNEL, "plane-%d", 234 drm_num_planes(dev)); 235 } 236 if (!plane->name) { 237 kfree(plane->format_types); 238 kfree(plane->modifiers); 239 drm_mode_object_unregister(dev, &plane->base); 240 return -ENOMEM; 241 } 242 243 memcpy(plane->format_types, formats, format_count * sizeof(uint32_t)); 244 plane->format_count = format_count; 245 memcpy(plane->modifiers, format_modifiers, 246 format_modifier_count * sizeof(format_modifiers[0])); 247 plane->possible_crtcs = possible_crtcs; 248 plane->type = type; 249 250 list_add_tail(&plane->head, &config->plane_list); 251 plane->index = config->num_total_plane++; 252 253 drm_object_attach_property(&plane->base, 254 config->plane_type_property, 255 plane->type); 256 257 if (drm_core_check_feature(dev, DRIVER_ATOMIC)) { 258 drm_object_attach_property(&plane->base, config->prop_fb_id, 0); 259 drm_object_attach_property(&plane->base, config->prop_in_fence_fd, -1); 260 drm_object_attach_property(&plane->base, config->prop_crtc_id, 0); 261 drm_object_attach_property(&plane->base, config->prop_crtc_x, 0); 262 drm_object_attach_property(&plane->base, config->prop_crtc_y, 0); 263 drm_object_attach_property(&plane->base, config->prop_crtc_w, 0); 264 drm_object_attach_property(&plane->base, config->prop_crtc_h, 0); 265 drm_object_attach_property(&plane->base, config->prop_src_x, 0); 266 drm_object_attach_property(&plane->base, config->prop_src_y, 0); 267 drm_object_attach_property(&plane->base, config->prop_src_w, 0); 268 drm_object_attach_property(&plane->base, config->prop_src_h, 0); 269 } 270 271 if (config->allow_fb_modifiers) 272 create_in_format_blob(dev, plane); 273 274 return 0; 275 } 276 EXPORT_SYMBOL(drm_universal_plane_init); 277 278 int drm_plane_register_all(struct drm_device *dev) 279 { 280 struct drm_plane *plane; 281 int ret = 0; 282 283 drm_for_each_plane(plane, dev) { 284 if (plane->funcs->late_register) 285 ret = plane->funcs->late_register(plane); 286 if (ret) 287 return ret; 288 } 289 290 return 0; 291 } 292 293 void drm_plane_unregister_all(struct drm_device *dev) 294 { 295 struct drm_plane *plane; 296 297 drm_for_each_plane(plane, dev) { 298 if (plane->funcs->early_unregister) 299 plane->funcs->early_unregister(plane); 300 } 301 } 302 303 /** 304 * drm_plane_init - Initialize a legacy plane 305 * @dev: DRM device 306 * @plane: plane object to init 307 * @possible_crtcs: bitmask of possible CRTCs 308 * @funcs: callbacks for the new plane 309 * @formats: array of supported formats (DRM_FORMAT\_\*) 310 * @format_count: number of elements in @formats 311 * @is_primary: plane type (primary vs overlay) 312 * 313 * Legacy API to initialize a DRM plane. 314 * 315 * New drivers should call drm_universal_plane_init() instead. 316 * 317 * Returns: 318 * Zero on success, error code on failure. 319 */ 320 int drm_plane_init(struct drm_device *dev, struct drm_plane *plane, 321 uint32_t possible_crtcs, 322 const struct drm_plane_funcs *funcs, 323 const uint32_t *formats, unsigned int format_count, 324 bool is_primary) 325 { 326 enum drm_plane_type type; 327 328 type = is_primary ? DRM_PLANE_TYPE_PRIMARY : DRM_PLANE_TYPE_OVERLAY; 329 return drm_universal_plane_init(dev, plane, possible_crtcs, funcs, 330 formats, format_count, 331 NULL, type, NULL); 332 } 333 EXPORT_SYMBOL(drm_plane_init); 334 335 /** 336 * drm_plane_cleanup - Clean up the core plane usage 337 * @plane: plane to cleanup 338 * 339 * This function cleans up @plane and removes it from the DRM mode setting 340 * core. Note that the function does *not* free the plane structure itself, 341 * this is the responsibility of the caller. 342 */ 343 void drm_plane_cleanup(struct drm_plane *plane) 344 { 345 struct drm_device *dev = plane->dev; 346 347 drm_modeset_lock_fini(&plane->mutex); 348 349 kfree(plane->format_types); 350 kfree(plane->modifiers); 351 drm_mode_object_unregister(dev, &plane->base); 352 353 BUG_ON(list_empty(&plane->head)); 354 355 /* Note that the plane_list is considered to be static; should we 356 * remove the drm_plane at runtime we would have to decrement all 357 * the indices on the drm_plane after us in the plane_list. 358 */ 359 360 list_del(&plane->head); 361 dev->mode_config.num_total_plane--; 362 363 WARN_ON(plane->state && !plane->funcs->atomic_destroy_state); 364 if (plane->state && plane->funcs->atomic_destroy_state) 365 plane->funcs->atomic_destroy_state(plane, plane->state); 366 367 kfree(plane->name); 368 369 memset(plane, 0, sizeof(*plane)); 370 } 371 EXPORT_SYMBOL(drm_plane_cleanup); 372 373 /** 374 * drm_plane_from_index - find the registered plane at an index 375 * @dev: DRM device 376 * @idx: index of registered plane to find for 377 * 378 * Given a plane index, return the registered plane from DRM device's 379 * list of planes with matching index. This is the inverse of drm_plane_index(). 380 */ 381 struct drm_plane * 382 drm_plane_from_index(struct drm_device *dev, int idx) 383 { 384 struct drm_plane *plane; 385 386 drm_for_each_plane(plane, dev) 387 if (idx == plane->index) 388 return plane; 389 390 return NULL; 391 } 392 EXPORT_SYMBOL(drm_plane_from_index); 393 394 /** 395 * drm_plane_force_disable - Forcibly disable a plane 396 * @plane: plane to disable 397 * 398 * Forces the plane to be disabled. 399 * 400 * Used when the plane's current framebuffer is destroyed, 401 * and when restoring fbdev mode. 402 * 403 * Note that this function is not suitable for atomic drivers, since it doesn't 404 * wire through the lock acquisition context properly and hence can't handle 405 * retries or driver private locks. You probably want to use 406 * drm_atomic_helper_disable_plane() or 407 * drm_atomic_helper_disable_planes_on_crtc() instead. 408 */ 409 void drm_plane_force_disable(struct drm_plane *plane) 410 { 411 int ret; 412 413 if (!plane->fb) 414 return; 415 416 WARN_ON(drm_drv_uses_atomic_modeset(plane->dev)); 417 418 plane->old_fb = plane->fb; 419 ret = plane->funcs->disable_plane(plane, NULL); 420 if (ret) { 421 DRM_ERROR("failed to disable plane with busy fb\n"); 422 plane->old_fb = NULL; 423 return; 424 } 425 /* disconnect the plane from the fb and crtc: */ 426 drm_framebuffer_put(plane->old_fb); 427 plane->old_fb = NULL; 428 plane->fb = NULL; 429 plane->crtc = NULL; 430 } 431 EXPORT_SYMBOL(drm_plane_force_disable); 432 433 /** 434 * drm_mode_plane_set_obj_prop - set the value of a property 435 * @plane: drm plane object to set property value for 436 * @property: property to set 437 * @value: value the property should be set to 438 * 439 * This functions sets a given property on a given plane object. This function 440 * calls the driver's ->set_property callback and changes the software state of 441 * the property if the callback succeeds. 442 * 443 * Returns: 444 * Zero on success, error code on failure. 445 */ 446 int drm_mode_plane_set_obj_prop(struct drm_plane *plane, 447 struct drm_property *property, 448 uint64_t value) 449 { 450 int ret = -EINVAL; 451 struct drm_mode_object *obj = &plane->base; 452 453 if (plane->funcs->set_property) 454 ret = plane->funcs->set_property(plane, property, value); 455 if (!ret) 456 drm_object_property_set_value(obj, property, value); 457 458 return ret; 459 } 460 EXPORT_SYMBOL(drm_mode_plane_set_obj_prop); 461 462 int drm_mode_getplane_res(struct drm_device *dev, void *data, 463 struct drm_file *file_priv) 464 { 465 struct drm_mode_get_plane_res *plane_resp = data; 466 struct drm_mode_config *config; 467 struct drm_plane *plane; 468 uint32_t __user *plane_ptr; 469 int count = 0; 470 471 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 472 return -EINVAL; 473 474 config = &dev->mode_config; 475 plane_ptr = u64_to_user_ptr(plane_resp->plane_id_ptr); 476 477 /* 478 * This ioctl is called twice, once to determine how much space is 479 * needed, and the 2nd time to fill it. 480 */ 481 drm_for_each_plane(plane, dev) { 482 /* 483 * Unless userspace set the 'universal planes' 484 * capability bit, only advertise overlays. 485 */ 486 if (plane->type != DRM_PLANE_TYPE_OVERLAY && 487 !file_priv->universal_planes) 488 continue; 489 490 if (drm_lease_held(file_priv, plane->base.id)) { 491 if (count < plane_resp->count_planes && 492 put_user(plane->base.id, plane_ptr + count)) 493 return -EFAULT; 494 count++; 495 } 496 } 497 plane_resp->count_planes = count; 498 499 return 0; 500 } 501 502 int drm_mode_getplane(struct drm_device *dev, void *data, 503 struct drm_file *file_priv) 504 { 505 struct drm_mode_get_plane *plane_resp = data; 506 struct drm_plane *plane; 507 uint32_t __user *format_ptr; 508 509 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 510 return -EINVAL; 511 512 plane = drm_plane_find(dev, file_priv, plane_resp->plane_id); 513 if (!plane) 514 return -ENOENT; 515 516 drm_modeset_lock(&plane->mutex, NULL); 517 if (plane->state && plane->state->crtc && drm_lease_held(file_priv, plane->state->crtc->base.id)) 518 plane_resp->crtc_id = plane->state->crtc->base.id; 519 else if (!plane->state && plane->crtc && drm_lease_held(file_priv, plane->crtc->base.id)) 520 plane_resp->crtc_id = plane->crtc->base.id; 521 else 522 plane_resp->crtc_id = 0; 523 524 if (plane->state && plane->state->fb) 525 plane_resp->fb_id = plane->state->fb->base.id; 526 else if (!plane->state && plane->fb) 527 plane_resp->fb_id = plane->fb->base.id; 528 else 529 plane_resp->fb_id = 0; 530 drm_modeset_unlock(&plane->mutex); 531 532 plane_resp->plane_id = plane->base.id; 533 plane_resp->possible_crtcs = drm_lease_filter_crtcs(file_priv, 534 plane->possible_crtcs); 535 536 plane_resp->gamma_size = 0; 537 538 /* 539 * This ioctl is called twice, once to determine how much space is 540 * needed, and the 2nd time to fill it. 541 */ 542 if (plane->format_count && 543 (plane_resp->count_format_types >= plane->format_count)) { 544 format_ptr = (uint32_t __user *)(unsigned long)plane_resp->format_type_ptr; 545 if (copy_to_user(format_ptr, 546 plane->format_types, 547 sizeof(uint32_t) * plane->format_count)) { 548 return -EFAULT; 549 } 550 } 551 plane_resp->count_format_types = plane->format_count; 552 553 return 0; 554 } 555 556 int drm_plane_check_pixel_format(struct drm_plane *plane, 557 u32 format, u64 modifier) 558 { 559 unsigned int i; 560 561 for (i = 0; i < plane->format_count; i++) { 562 if (format == plane->format_types[i]) 563 break; 564 } 565 if (i == plane->format_count) 566 return -EINVAL; 567 568 if (plane->funcs->format_mod_supported) { 569 if (!plane->funcs->format_mod_supported(plane, format, modifier)) 570 return -EINVAL; 571 } else { 572 if (!plane->modifier_count) 573 return 0; 574 575 for (i = 0; i < plane->modifier_count; i++) { 576 if (modifier == plane->modifiers[i]) 577 break; 578 } 579 if (i == plane->modifier_count) 580 return -EINVAL; 581 } 582 583 return 0; 584 } 585 586 /* 587 * __setplane_internal - setplane handler for internal callers 588 * 589 * This function will take a reference on the new fb for the plane 590 * on success. 591 * 592 * src_{x,y,w,h} are provided in 16.16 fixed point format 593 */ 594 static int __setplane_internal(struct drm_plane *plane, 595 struct drm_crtc *crtc, 596 struct drm_framebuffer *fb, 597 int32_t crtc_x, int32_t crtc_y, 598 uint32_t crtc_w, uint32_t crtc_h, 599 /* src_{x,y,w,h} values are 16.16 fixed point */ 600 uint32_t src_x, uint32_t src_y, 601 uint32_t src_w, uint32_t src_h, 602 struct drm_modeset_acquire_ctx *ctx) 603 { 604 int ret = 0; 605 606 /* No fb means shut it down */ 607 if (!fb) { 608 plane->old_fb = plane->fb; 609 ret = plane->funcs->disable_plane(plane, ctx); 610 if (!ret) { 611 plane->crtc = NULL; 612 plane->fb = NULL; 613 } else { 614 plane->old_fb = NULL; 615 } 616 goto out; 617 } 618 619 /* Check whether this plane is usable on this CRTC */ 620 if (!(plane->possible_crtcs & drm_crtc_mask(crtc))) { 621 DRM_DEBUG_KMS("Invalid crtc for plane\n"); 622 ret = -EINVAL; 623 goto out; 624 } 625 626 /* Check whether this plane supports the fb pixel format. */ 627 ret = drm_plane_check_pixel_format(plane, fb->format->format, 628 fb->modifier); 629 if (ret) { 630 struct drm_format_name_buf format_name; 631 DRM_DEBUG_KMS("Invalid pixel format %s, modifier 0x%llx\n", 632 drm_get_format_name(fb->format->format, 633 &format_name), 634 fb->modifier); 635 goto out; 636 } 637 638 /* Give drivers some help against integer overflows */ 639 if (crtc_w > INT_MAX || 640 crtc_x > INT_MAX - (int32_t) crtc_w || 641 crtc_h > INT_MAX || 642 crtc_y > INT_MAX - (int32_t) crtc_h) { 643 DRM_DEBUG_KMS("Invalid CRTC coordinates %ux%u+%d+%d\n", 644 crtc_w, crtc_h, crtc_x, crtc_y); 645 ret = -ERANGE; 646 goto out; 647 } 648 649 ret = drm_framebuffer_check_src_coords(src_x, src_y, src_w, src_h, fb); 650 if (ret) 651 goto out; 652 653 plane->old_fb = plane->fb; 654 ret = plane->funcs->update_plane(plane, crtc, fb, 655 crtc_x, crtc_y, crtc_w, crtc_h, 656 src_x, src_y, src_w, src_h, ctx); 657 if (!ret) { 658 if (!plane->state) { 659 plane->crtc = crtc; 660 plane->fb = fb; 661 drm_framebuffer_get(plane->fb); 662 } 663 } else { 664 plane->old_fb = NULL; 665 } 666 667 out: 668 if (plane->old_fb) 669 drm_framebuffer_put(plane->old_fb); 670 plane->old_fb = NULL; 671 672 return ret; 673 } 674 675 static int setplane_internal(struct drm_plane *plane, 676 struct drm_crtc *crtc, 677 struct drm_framebuffer *fb, 678 int32_t crtc_x, int32_t crtc_y, 679 uint32_t crtc_w, uint32_t crtc_h, 680 /* src_{x,y,w,h} values are 16.16 fixed point */ 681 uint32_t src_x, uint32_t src_y, 682 uint32_t src_w, uint32_t src_h) 683 { 684 struct drm_modeset_acquire_ctx ctx; 685 int ret; 686 687 drm_modeset_acquire_init(&ctx, DRM_MODESET_ACQUIRE_INTERRUPTIBLE); 688 retry: 689 ret = drm_modeset_lock_all_ctx(plane->dev, &ctx); 690 if (ret) 691 goto fail; 692 ret = __setplane_internal(plane, crtc, fb, 693 crtc_x, crtc_y, crtc_w, crtc_h, 694 src_x, src_y, src_w, src_h, &ctx); 695 696 fail: 697 if (ret == -EDEADLK) { 698 ret = drm_modeset_backoff(&ctx); 699 if (!ret) 700 goto retry; 701 } 702 drm_modeset_drop_locks(&ctx); 703 drm_modeset_acquire_fini(&ctx); 704 705 return ret; 706 } 707 708 int drm_mode_setplane(struct drm_device *dev, void *data, 709 struct drm_file *file_priv) 710 { 711 struct drm_mode_set_plane *plane_req = data; 712 struct drm_plane *plane; 713 struct drm_crtc *crtc = NULL; 714 struct drm_framebuffer *fb = NULL; 715 int ret; 716 717 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 718 return -EINVAL; 719 720 /* 721 * First, find the plane, crtc, and fb objects. If not available, 722 * we don't bother to call the driver. 723 */ 724 plane = drm_plane_find(dev, file_priv, plane_req->plane_id); 725 if (!plane) { 726 DRM_DEBUG_KMS("Unknown plane ID %d\n", 727 plane_req->plane_id); 728 return -ENOENT; 729 } 730 731 if (plane_req->fb_id) { 732 fb = drm_framebuffer_lookup(dev, file_priv, plane_req->fb_id); 733 if (!fb) { 734 DRM_DEBUG_KMS("Unknown framebuffer ID %d\n", 735 plane_req->fb_id); 736 return -ENOENT; 737 } 738 739 crtc = drm_crtc_find(dev, file_priv, plane_req->crtc_id); 740 if (!crtc) { 741 drm_framebuffer_put(fb); 742 DRM_DEBUG_KMS("Unknown crtc ID %d\n", 743 plane_req->crtc_id); 744 return -ENOENT; 745 } 746 } 747 748 ret = setplane_internal(plane, crtc, fb, 749 plane_req->crtc_x, plane_req->crtc_y, 750 plane_req->crtc_w, plane_req->crtc_h, 751 plane_req->src_x, plane_req->src_y, 752 plane_req->src_w, plane_req->src_h); 753 754 if (fb) 755 drm_framebuffer_put(fb); 756 757 return ret; 758 } 759 760 static int drm_mode_cursor_universal(struct drm_crtc *crtc, 761 struct drm_mode_cursor2 *req, 762 struct drm_file *file_priv, 763 struct drm_modeset_acquire_ctx *ctx) 764 { 765 struct drm_device *dev = crtc->dev; 766 struct drm_plane *plane = crtc->cursor; 767 struct drm_framebuffer *fb = NULL; 768 struct drm_mode_fb_cmd2 fbreq = { 769 .width = req->width, 770 .height = req->height, 771 .pixel_format = DRM_FORMAT_ARGB8888, 772 .pitches = { req->width * 4 }, 773 .handles = { req->handle }, 774 }; 775 int32_t crtc_x, crtc_y; 776 uint32_t crtc_w = 0, crtc_h = 0; 777 uint32_t src_w = 0, src_h = 0; 778 int ret = 0; 779 780 BUG_ON(!plane); 781 WARN_ON(plane->crtc != crtc && plane->crtc != NULL); 782 783 /* 784 * Obtain fb we'll be using (either new or existing) and take an extra 785 * reference to it if fb != null. setplane will take care of dropping 786 * the reference if the plane update fails. 787 */ 788 if (req->flags & DRM_MODE_CURSOR_BO) { 789 if (req->handle) { 790 fb = drm_internal_framebuffer_create(dev, &fbreq, file_priv); 791 if (IS_ERR(fb)) { 792 DRM_DEBUG_KMS("failed to wrap cursor buffer in drm framebuffer\n"); 793 return PTR_ERR(fb); 794 } 795 796 fb->hot_x = req->hot_x; 797 fb->hot_y = req->hot_y; 798 } else { 799 fb = NULL; 800 } 801 } else { 802 if (plane->state) 803 fb = plane->state->fb; 804 else 805 fb = plane->fb; 806 807 if (fb) 808 drm_framebuffer_get(fb); 809 } 810 811 if (req->flags & DRM_MODE_CURSOR_MOVE) { 812 crtc_x = req->x; 813 crtc_y = req->y; 814 } else { 815 crtc_x = crtc->cursor_x; 816 crtc_y = crtc->cursor_y; 817 } 818 819 if (fb) { 820 crtc_w = fb->width; 821 crtc_h = fb->height; 822 src_w = fb->width << 16; 823 src_h = fb->height << 16; 824 } 825 826 ret = __setplane_internal(plane, crtc, fb, 827 crtc_x, crtc_y, crtc_w, crtc_h, 828 0, 0, src_w, src_h, ctx); 829 830 if (fb) 831 drm_framebuffer_put(fb); 832 833 /* Update successful; save new cursor position, if necessary */ 834 if (ret == 0 && req->flags & DRM_MODE_CURSOR_MOVE) { 835 crtc->cursor_x = req->x; 836 crtc->cursor_y = req->y; 837 } 838 839 return ret; 840 } 841 842 static int drm_mode_cursor_common(struct drm_device *dev, 843 struct drm_mode_cursor2 *req, 844 struct drm_file *file_priv) 845 { 846 struct drm_crtc *crtc; 847 struct drm_modeset_acquire_ctx ctx; 848 int ret = 0; 849 850 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 851 return -EINVAL; 852 853 if (!req->flags || (~DRM_MODE_CURSOR_FLAGS & req->flags)) 854 return -EINVAL; 855 856 crtc = drm_crtc_find(dev, file_priv, req->crtc_id); 857 if (!crtc) { 858 DRM_DEBUG_KMS("Unknown CRTC ID %d\n", req->crtc_id); 859 return -ENOENT; 860 } 861 862 drm_modeset_acquire_init(&ctx, DRM_MODESET_ACQUIRE_INTERRUPTIBLE); 863 retry: 864 ret = drm_modeset_lock(&crtc->mutex, &ctx); 865 if (ret) 866 goto out; 867 /* 868 * If this crtc has a universal cursor plane, call that plane's update 869 * handler rather than using legacy cursor handlers. 870 */ 871 if (crtc->cursor) { 872 ret = drm_modeset_lock(&crtc->cursor->mutex, &ctx); 873 if (ret) 874 goto out; 875 876 ret = drm_mode_cursor_universal(crtc, req, file_priv, &ctx); 877 goto out; 878 } 879 880 if (req->flags & DRM_MODE_CURSOR_BO) { 881 if (!crtc->funcs->cursor_set && !crtc->funcs->cursor_set2) { 882 ret = -ENXIO; 883 goto out; 884 } 885 /* Turns off the cursor if handle is 0 */ 886 if (crtc->funcs->cursor_set2) 887 ret = crtc->funcs->cursor_set2(crtc, file_priv, req->handle, 888 req->width, req->height, req->hot_x, req->hot_y); 889 else 890 ret = crtc->funcs->cursor_set(crtc, file_priv, req->handle, 891 req->width, req->height); 892 } 893 894 if (req->flags & DRM_MODE_CURSOR_MOVE) { 895 if (crtc->funcs->cursor_move) { 896 ret = crtc->funcs->cursor_move(crtc, req->x, req->y); 897 } else { 898 ret = -EFAULT; 899 goto out; 900 } 901 } 902 out: 903 if (ret == -EDEADLK) { 904 ret = drm_modeset_backoff(&ctx); 905 if (!ret) 906 goto retry; 907 } 908 909 drm_modeset_drop_locks(&ctx); 910 drm_modeset_acquire_fini(&ctx); 911 912 return ret; 913 914 } 915 916 917 int drm_mode_cursor_ioctl(struct drm_device *dev, 918 void *data, struct drm_file *file_priv) 919 { 920 struct drm_mode_cursor *req = data; 921 struct drm_mode_cursor2 new_req; 922 923 memcpy(&new_req, req, sizeof(struct drm_mode_cursor)); 924 new_req.hot_x = new_req.hot_y = 0; 925 926 return drm_mode_cursor_common(dev, &new_req, file_priv); 927 } 928 929 /* 930 * Set the cursor configuration based on user request. This implements the 2nd 931 * version of the cursor ioctl, which allows userspace to additionally specify 932 * the hotspot of the pointer. 933 */ 934 int drm_mode_cursor2_ioctl(struct drm_device *dev, 935 void *data, struct drm_file *file_priv) 936 { 937 struct drm_mode_cursor2 *req = data; 938 939 return drm_mode_cursor_common(dev, req, file_priv); 940 } 941 942 int drm_mode_page_flip_ioctl(struct drm_device *dev, 943 void *data, struct drm_file *file_priv) 944 { 945 struct drm_mode_crtc_page_flip_target *page_flip = data; 946 struct drm_crtc *crtc; 947 struct drm_plane *plane; 948 struct drm_framebuffer *fb = NULL, *old_fb; 949 struct drm_pending_vblank_event *e = NULL; 950 u32 target_vblank = page_flip->sequence; 951 struct drm_modeset_acquire_ctx ctx; 952 int ret = -EINVAL; 953 954 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 955 return -EINVAL; 956 957 if (page_flip->flags & ~DRM_MODE_PAGE_FLIP_FLAGS) 958 return -EINVAL; 959 960 if (page_flip->sequence != 0 && !(page_flip->flags & DRM_MODE_PAGE_FLIP_TARGET)) 961 return -EINVAL; 962 963 /* Only one of the DRM_MODE_PAGE_FLIP_TARGET_ABSOLUTE/RELATIVE flags 964 * can be specified 965 */ 966 if ((page_flip->flags & DRM_MODE_PAGE_FLIP_TARGET) == DRM_MODE_PAGE_FLIP_TARGET) 967 return -EINVAL; 968 969 if ((page_flip->flags & DRM_MODE_PAGE_FLIP_ASYNC) && !dev->mode_config.async_page_flip) 970 return -EINVAL; 971 972 crtc = drm_crtc_find(dev, file_priv, page_flip->crtc_id); 973 if (!crtc) 974 return -ENOENT; 975 976 plane = crtc->primary; 977 978 if (crtc->funcs->page_flip_target) { 979 u32 current_vblank; 980 int r; 981 982 r = drm_crtc_vblank_get(crtc); 983 if (r) 984 return r; 985 986 current_vblank = (u32)drm_crtc_vblank_count(crtc); 987 988 switch (page_flip->flags & DRM_MODE_PAGE_FLIP_TARGET) { 989 case DRM_MODE_PAGE_FLIP_TARGET_ABSOLUTE: 990 if ((int)(target_vblank - current_vblank) > 1) { 991 DRM_DEBUG("Invalid absolute flip target %u, " 992 "must be <= %u\n", target_vblank, 993 current_vblank + 1); 994 drm_crtc_vblank_put(crtc); 995 return -EINVAL; 996 } 997 break; 998 case DRM_MODE_PAGE_FLIP_TARGET_RELATIVE: 999 if (target_vblank != 0 && target_vblank != 1) { 1000 DRM_DEBUG("Invalid relative flip target %u, " 1001 "must be 0 or 1\n", target_vblank); 1002 drm_crtc_vblank_put(crtc); 1003 return -EINVAL; 1004 } 1005 target_vblank += current_vblank; 1006 break; 1007 default: 1008 target_vblank = current_vblank + 1009 !(page_flip->flags & DRM_MODE_PAGE_FLIP_ASYNC); 1010 break; 1011 } 1012 } else if (crtc->funcs->page_flip == NULL || 1013 (page_flip->flags & DRM_MODE_PAGE_FLIP_TARGET)) { 1014 return -EINVAL; 1015 } 1016 1017 drm_modeset_acquire_init(&ctx, DRM_MODESET_ACQUIRE_INTERRUPTIBLE); 1018 retry: 1019 ret = drm_modeset_lock(&crtc->mutex, &ctx); 1020 if (ret) 1021 goto out; 1022 ret = drm_modeset_lock(&plane->mutex, &ctx); 1023 if (ret) 1024 goto out; 1025 1026 if (plane->state) 1027 old_fb = plane->state->fb; 1028 else 1029 old_fb = plane->fb; 1030 1031 if (old_fb == NULL) { 1032 /* The framebuffer is currently unbound, presumably 1033 * due to a hotplug event, that userspace has not 1034 * yet discovered. 1035 */ 1036 ret = -EBUSY; 1037 goto out; 1038 } 1039 1040 fb = drm_framebuffer_lookup(dev, file_priv, page_flip->fb_id); 1041 if (!fb) { 1042 ret = -ENOENT; 1043 goto out; 1044 } 1045 1046 if (plane->state) { 1047 const struct drm_plane_state *state = plane->state; 1048 1049 ret = drm_framebuffer_check_src_coords(state->src_x, 1050 state->src_y, 1051 state->src_w, 1052 state->src_h, 1053 fb); 1054 } else { 1055 ret = drm_crtc_check_viewport(crtc, crtc->x, crtc->y, 1056 &crtc->mode, fb); 1057 } 1058 if (ret) 1059 goto out; 1060 1061 if (old_fb->format != fb->format) { 1062 DRM_DEBUG_KMS("Page flip is not allowed to change frame buffer format.\n"); 1063 ret = -EINVAL; 1064 goto out; 1065 } 1066 1067 if (page_flip->flags & DRM_MODE_PAGE_FLIP_EVENT) { 1068 e = kzalloc(sizeof *e, GFP_KERNEL); 1069 if (!e) { 1070 ret = -ENOMEM; 1071 goto out; 1072 } 1073 1074 e->event.base.type = DRM_EVENT_FLIP_COMPLETE; 1075 e->event.base.length = sizeof(e->event); 1076 e->event.vbl.user_data = page_flip->user_data; 1077 e->event.vbl.crtc_id = crtc->base.id; 1078 1079 ret = drm_event_reserve_init(dev, file_priv, &e->base, &e->event.base); 1080 if (ret) { 1081 kfree(e); 1082 e = NULL; 1083 goto out; 1084 } 1085 } 1086 1087 plane->old_fb = plane->fb; 1088 if (crtc->funcs->page_flip_target) 1089 ret = crtc->funcs->page_flip_target(crtc, fb, e, 1090 page_flip->flags, 1091 target_vblank, 1092 &ctx); 1093 else 1094 ret = crtc->funcs->page_flip(crtc, fb, e, page_flip->flags, 1095 &ctx); 1096 if (ret) { 1097 if (page_flip->flags & DRM_MODE_PAGE_FLIP_EVENT) 1098 drm_event_cancel_free(dev, &e->base); 1099 /* Keep the old fb, don't unref it. */ 1100 plane->old_fb = NULL; 1101 } else { 1102 if (!plane->state) { 1103 plane->fb = fb; 1104 drm_framebuffer_get(fb); 1105 } 1106 } 1107 1108 out: 1109 if (fb) 1110 drm_framebuffer_put(fb); 1111 if (plane->old_fb) 1112 drm_framebuffer_put(plane->old_fb); 1113 plane->old_fb = NULL; 1114 1115 if (ret == -EDEADLK) { 1116 ret = drm_modeset_backoff(&ctx); 1117 if (!ret) 1118 goto retry; 1119 } 1120 1121 drm_modeset_drop_locks(&ctx); 1122 drm_modeset_acquire_fini(&ctx); 1123 1124 if (ret && crtc->funcs->page_flip_target) 1125 drm_crtc_vblank_put(crtc); 1126 1127 return ret; 1128 } 1129