Linux Audio

Check our new training course

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