1/*
   2 * Copyright (C) 2014 Red Hat
   3 * Copyright (C) 2014 Intel Corp.
   4 *
   5 * Permission is hereby granted, free of charge, to any person obtaining a
   6 * copy of this software and associated documentation files (the "Software"),
   7 * to deal in the Software without restriction, including without limitation
   8 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9 * and/or sell copies of the Software, and to permit persons to whom the
  10 * Software is furnished to do so, subject to the following conditions:
  11 *
  12 * The above copyright notice and this permission notice shall be included in
  13 * all copies or substantial portions of the Software.
  14 *
  15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
  19 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  20 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  21 * OTHER DEALINGS IN THE SOFTWARE.
  22 *
  23 * Authors:
  24 * Rob Clark <robdclark@gmail.com>
  25 * Daniel Vetter <daniel.vetter@ffwll.ch>
  26 */
  27
  28
  29#include <drm/drmP.h>
  30#include <drm/drm_atomic.h>
  31#include <drm/drm_mode.h>
  32#include <drm/drm_plane_helper.h>
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  33
  34/**
  35 * drm_atomic_state_default_release -
  36 * release memory initialized by drm_atomic_state_init
  37 * @state: atomic state
  38 *
  39 * Free all the memory allocated by drm_atomic_state_init.
  40 * This is useful for drivers that subclass the atomic state.
  41 */
  42void drm_atomic_state_default_release(struct drm_atomic_state *state)
  43{
  44	kfree(state->connectors);
  45	kfree(state->connector_states);
  46	kfree(state->crtcs);
  47	kfree(state->crtc_states);
  48	kfree(state->planes);
  49	kfree(state->plane_states);
  50}
  51EXPORT_SYMBOL(drm_atomic_state_default_release);
  52
  53/**
  54 * drm_atomic_state_init - init new atomic state
  55 * @dev: DRM device
  56 * @state: atomic state
  57 *
  58 * Default implementation for filling in a new atomic state.
  59 * This is useful for drivers that subclass the atomic state.
  60 */
  61int
  62drm_atomic_state_init(struct drm_device *dev, struct drm_atomic_state *state)
  63{
 
 
  64	/* TODO legacy paths should maybe do a better job about
  65	 * setting this appropriately?
  66	 */
  67	state->allow_modeset = true;
  68
  69	state->crtcs = kcalloc(dev->mode_config.num_crtc,
  70			       sizeof(*state->crtcs), GFP_KERNEL);
  71	if (!state->crtcs)
  72		goto fail;
  73	state->crtc_states = kcalloc(dev->mode_config.num_crtc,
  74				     sizeof(*state->crtc_states), GFP_KERNEL);
  75	if (!state->crtc_states)
  76		goto fail;
  77	state->planes = kcalloc(dev->mode_config.num_total_plane,
  78				sizeof(*state->planes), GFP_KERNEL);
  79	if (!state->planes)
  80		goto fail;
  81	state->plane_states = kcalloc(dev->mode_config.num_total_plane,
  82				      sizeof(*state->plane_states), GFP_KERNEL);
  83	if (!state->plane_states)
  84		goto fail;
  85
  86	state->dev = dev;
  87
  88	DRM_DEBUG_ATOMIC("Allocated atomic state %p\n", state);
  89
  90	return 0;
  91fail:
  92	drm_atomic_state_default_release(state);
  93	return -ENOMEM;
  94}
  95EXPORT_SYMBOL(drm_atomic_state_init);
  96
  97/**
  98 * drm_atomic_state_alloc - allocate atomic state
  99 * @dev: DRM device
 100 *
 101 * This allocates an empty atomic state to track updates.
 102 */
 103struct drm_atomic_state *
 104drm_atomic_state_alloc(struct drm_device *dev)
 105{
 106	struct drm_mode_config *config = &dev->mode_config;
 107	struct drm_atomic_state *state;
 108
 109	if (!config->funcs->atomic_state_alloc) {
 110		state = kzalloc(sizeof(*state), GFP_KERNEL);
 111		if (!state)
 112			return NULL;
 113		if (drm_atomic_state_init(dev, state) < 0) {
 114			kfree(state);
 115			return NULL;
 116		}
 117		return state;
 118	}
 119
 120	return config->funcs->atomic_state_alloc(dev);
 121}
 122EXPORT_SYMBOL(drm_atomic_state_alloc);
 123
 124/**
 125 * drm_atomic_state_default_clear - clear base atomic state
 126 * @state: atomic state
 127 *
 128 * Default implementation for clearing atomic state.
 129 * This is useful for drivers that subclass the atomic state.
 130 */
 131void drm_atomic_state_default_clear(struct drm_atomic_state *state)
 132{
 133	struct drm_device *dev = state->dev;
 134	struct drm_mode_config *config = &dev->mode_config;
 135	int i;
 136
 137	DRM_DEBUG_ATOMIC("Clearing atomic state %p\n", state);
 138
 139	for (i = 0; i < state->num_connector; i++) {
 140		struct drm_connector *connector = state->connectors[i];
 141
 142		if (!connector)
 143			continue;
 144
 145		/*
 146		 * FIXME: Async commits can race with connector unplugging and
 147		 * there's currently nothing that prevents cleanup up state for
 148		 * deleted connectors. As long as the callback doesn't look at
 149		 * the connector we'll be fine though, so make sure that's the
 150		 * case by setting all connector pointers to NULL.
 151		 */
 152		state->connector_states[i]->connector = NULL;
 153		connector->funcs->atomic_destroy_state(NULL,
 154						       state->connector_states[i]);
 155		state->connectors[i] = NULL;
 156		state->connector_states[i] = NULL;
 157	}
 158
 159	for (i = 0; i < config->num_crtc; i++) {
 160		struct drm_crtc *crtc = state->crtcs[i];
 161
 162		if (!crtc)
 163			continue;
 164
 165		crtc->funcs->atomic_destroy_state(crtc,
 166						  state->crtc_states[i]);
 167		state->crtcs[i] = NULL;
 168		state->crtc_states[i] = NULL;
 
 
 
 
 
 
 
 
 169	}
 170
 171	for (i = 0; i < config->num_total_plane; i++) {
 172		struct drm_plane *plane = state->planes[i];
 173
 174		if (!plane)
 175			continue;
 176
 177		plane->funcs->atomic_destroy_state(plane,
 178						   state->plane_states[i]);
 179		state->planes[i] = NULL;
 180		state->plane_states[i] = NULL;
 181	}
 182}
 183EXPORT_SYMBOL(drm_atomic_state_default_clear);
 184
 185/**
 186 * drm_atomic_state_clear - clear state object
 187 * @state: atomic state
 188 *
 189 * When the w/w mutex algorithm detects a deadlock we need to back off and drop
 190 * all locks. So someone else could sneak in and change the current modeset
 191 * configuration. Which means that all the state assembled in @state is no
 192 * longer an atomic update to the current state, but to some arbitrary earlier
 193 * state. Which could break assumptions the driver's ->atomic_check likely
 194 * relies on.
 195 *
 196 * Hence we must clear all cached state and completely start over, using this
 197 * function.
 198 */
 199void drm_atomic_state_clear(struct drm_atomic_state *state)
 200{
 201	struct drm_device *dev = state->dev;
 202	struct drm_mode_config *config = &dev->mode_config;
 203
 204	if (config->funcs->atomic_state_clear)
 205		config->funcs->atomic_state_clear(state);
 206	else
 207		drm_atomic_state_default_clear(state);
 208}
 209EXPORT_SYMBOL(drm_atomic_state_clear);
 210
 211/**
 212 * drm_atomic_state_free - free all memory for an atomic state
 213 * @state: atomic state to deallocate
 214 *
 215 * This frees all memory associated with an atomic state, including all the
 216 * per-object state for planes, crtcs and connectors.
 217 */
 218void drm_atomic_state_free(struct drm_atomic_state *state)
 219{
 220	struct drm_device *dev;
 221	struct drm_mode_config *config;
 222
 223	if (!state)
 224		return;
 225
 226	dev = state->dev;
 227	config = &dev->mode_config;
 228
 229	drm_atomic_state_clear(state);
 230
 231	DRM_DEBUG_ATOMIC("Freeing atomic state %p\n", state);
 232
 233	if (config->funcs->atomic_state_free) {
 234		config->funcs->atomic_state_free(state);
 235	} else {
 236		drm_atomic_state_default_release(state);
 237		kfree(state);
 238	}
 239}
 240EXPORT_SYMBOL(drm_atomic_state_free);
 241
 242/**
 243 * drm_atomic_get_crtc_state - get crtc state
 244 * @state: global atomic state object
 245 * @crtc: crtc to get state object for
 246 *
 247 * This function returns the crtc state for the given crtc, allocating it if
 248 * needed. It will also grab the relevant crtc lock to make sure that the state
 249 * is consistent.
 250 *
 251 * Returns:
 252 *
 253 * Either the allocated state or the error code encoded into the pointer. When
 254 * the error is EDEADLK then the w/w mutex code has detected a deadlock and the
 255 * entire atomic sequence must be restarted. All other errors are fatal.
 256 */
 257struct drm_crtc_state *
 258drm_atomic_get_crtc_state(struct drm_atomic_state *state,
 259			  struct drm_crtc *crtc)
 260{
 261	int ret, index = drm_crtc_index(crtc);
 262	struct drm_crtc_state *crtc_state;
 263
 
 
 264	crtc_state = drm_atomic_get_existing_crtc_state(state, crtc);
 265	if (crtc_state)
 266		return crtc_state;
 267
 268	ret = drm_modeset_lock(&crtc->mutex, state->acquire_ctx);
 269	if (ret)
 270		return ERR_PTR(ret);
 271
 272	crtc_state = crtc->funcs->atomic_duplicate_state(crtc);
 273	if (!crtc_state)
 274		return ERR_PTR(-ENOMEM);
 275
 276	state->crtc_states[index] = crtc_state;
 277	state->crtcs[index] = crtc;
 278	crtc_state->state = state;
 279
 280	DRM_DEBUG_ATOMIC("Added [CRTC:%d:%s] %p state to %p\n",
 281			 crtc->base.id, crtc->name, crtc_state, state);
 282
 283	return crtc_state;
 284}
 285EXPORT_SYMBOL(drm_atomic_get_crtc_state);
 286
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 287/**
 288 * drm_atomic_set_mode_for_crtc - set mode for CRTC
 289 * @state: the CRTC whose incoming state to update
 290 * @mode: kernel-internal mode to use for the CRTC, or NULL to disable
 291 *
 292 * Set a mode (originating from the kernel) on the desired CRTC state. Does
 293 * not change any other state properties, including enable, active, or
 294 * mode_changed.
 295 *
 296 * RETURNS:
 297 * Zero on success, error code on failure. Cannot return -EDEADLK.
 298 */
 299int drm_atomic_set_mode_for_crtc(struct drm_crtc_state *state,
 300				 struct drm_display_mode *mode)
 301{
 302	struct drm_mode_modeinfo umode;
 303
 304	/* Early return for no change. */
 305	if (mode && memcmp(&state->mode, mode, sizeof(*mode)) == 0)
 306		return 0;
 307
 308	drm_property_unreference_blob(state->mode_blob);
 309	state->mode_blob = NULL;
 310
 311	if (mode) {
 312		drm_mode_convert_to_umode(&umode, mode);
 313		state->mode_blob =
 314			drm_property_create_blob(state->crtc->dev,
 315		                                 sizeof(umode),
 316		                                 &umode);
 317		if (IS_ERR(state->mode_blob))
 318			return PTR_ERR(state->mode_blob);
 319
 320		drm_mode_copy(&state->mode, mode);
 321		state->enable = true;
 322		DRM_DEBUG_ATOMIC("Set [MODE:%s] for CRTC state %p\n",
 323				 mode->name, state);
 324	} else {
 325		memset(&state->mode, 0, sizeof(state->mode));
 326		state->enable = false;
 327		DRM_DEBUG_ATOMIC("Set [NOMODE] for CRTC state %p\n",
 328				 state);
 329	}
 330
 331	return 0;
 332}
 333EXPORT_SYMBOL(drm_atomic_set_mode_for_crtc);
 334
 335/**
 336 * drm_atomic_set_mode_prop_for_crtc - set mode for CRTC
 337 * @state: the CRTC whose incoming state to update
 338 * @blob: pointer to blob property to use for mode
 339 *
 340 * Set a mode (originating from a blob property) on the desired CRTC state.
 341 * This function will take a reference on the blob property for the CRTC state,
 342 * and release the reference held on the state's existing mode property, if any
 343 * was set.
 344 *
 345 * RETURNS:
 346 * Zero on success, error code on failure. Cannot return -EDEADLK.
 347 */
 348int drm_atomic_set_mode_prop_for_crtc(struct drm_crtc_state *state,
 349                                      struct drm_property_blob *blob)
 350{
 351	if (blob == state->mode_blob)
 352		return 0;
 353
 354	drm_property_unreference_blob(state->mode_blob);
 355	state->mode_blob = NULL;
 356
 
 
 357	if (blob) {
 358		if (blob->length != sizeof(struct drm_mode_modeinfo) ||
 359		    drm_mode_convert_umode(&state->mode,
 360		                           (const struct drm_mode_modeinfo *)
 361		                            blob->data))
 362			return -EINVAL;
 363
 364		state->mode_blob = drm_property_reference_blob(blob);
 365		state->enable = true;
 366		DRM_DEBUG_ATOMIC("Set [MODE:%s] for CRTC state %p\n",
 367				 state->mode.name, state);
 368	} else {
 369		memset(&state->mode, 0, sizeof(state->mode));
 370		state->enable = false;
 371		DRM_DEBUG_ATOMIC("Set [NOMODE] for CRTC state %p\n",
 372				 state);
 373	}
 374
 375	return 0;
 376}
 377EXPORT_SYMBOL(drm_atomic_set_mode_prop_for_crtc);
 378
 379/**
 380 * drm_atomic_replace_property_blob - replace a blob property
 381 * @blob: a pointer to the member blob to be replaced
 382 * @new_blob: the new blob to replace with
 383 * @replaced: whether the blob has been replaced
 384 *
 385 * RETURNS:
 386 * Zero on success, error code on failure
 387 */
 388static void
 389drm_atomic_replace_property_blob(struct drm_property_blob **blob,
 390				 struct drm_property_blob *new_blob,
 391				 bool *replaced)
 392{
 393	struct drm_property_blob *old_blob = *blob;
 394
 395	if (old_blob == new_blob)
 396		return;
 397
 398	if (old_blob)
 399		drm_property_unreference_blob(old_blob);
 400	if (new_blob)
 401		drm_property_reference_blob(new_blob);
 402	*blob = new_blob;
 403	*replaced = true;
 404
 405	return;
 406}
 407
 408static int
 409drm_atomic_replace_property_blob_from_id(struct drm_crtc *crtc,
 410					 struct drm_property_blob **blob,
 411					 uint64_t blob_id,
 412					 ssize_t expected_size,
 413					 bool *replaced)
 414{
 415	struct drm_device *dev = crtc->dev;
 416	struct drm_property_blob *new_blob = NULL;
 417
 418	if (blob_id != 0) {
 419		new_blob = drm_property_lookup_blob(dev, blob_id);
 420		if (new_blob == NULL)
 421			return -EINVAL;
 422		if (expected_size > 0 && expected_size != new_blob->length)
 
 
 423			return -EINVAL;
 
 424	}
 425
 426	drm_atomic_replace_property_blob(blob, new_blob, replaced);
 
 427
 428	return 0;
 429}
 430
 431/**
 432 * drm_atomic_crtc_set_property - set property on CRTC
 433 * @crtc: the drm CRTC to set a property on
 434 * @state: the state object to update with the new property value
 435 * @property: the property to set
 436 * @val: the new property value
 437 *
 438 * Use this instead of calling crtc->atomic_set_property directly.
 439 * This function handles generic/core properties and calls out to
 440 * driver's ->atomic_set_property() for driver properties.  To ensure
 441 * consistent behavior you must call this function rather than the
 442 * driver hook directly.
 443 *
 444 * RETURNS:
 445 * Zero on success, error code on failure
 446 */
 447int drm_atomic_crtc_set_property(struct drm_crtc *crtc,
 448		struct drm_crtc_state *state, struct drm_property *property,
 449		uint64_t val)
 450{
 451	struct drm_device *dev = crtc->dev;
 452	struct drm_mode_config *config = &dev->mode_config;
 453	bool replaced = false;
 454	int ret;
 455
 456	if (property == config->prop_active)
 457		state->active = val;
 458	else if (property == config->prop_mode_id) {
 459		struct drm_property_blob *mode =
 460			drm_property_lookup_blob(dev, val);
 461		ret = drm_atomic_set_mode_prop_for_crtc(state, mode);
 462		drm_property_unreference_blob(mode);
 463		return ret;
 464	} else if (property == config->degamma_lut_property) {
 465		ret = drm_atomic_replace_property_blob_from_id(crtc,
 466					&state->degamma_lut,
 467					val,
 468					-1,
 469					&replaced);
 470		state->color_mgmt_changed = replaced;
 471		return ret;
 472	} else if (property == config->ctm_property) {
 473		ret = drm_atomic_replace_property_blob_from_id(crtc,
 474					&state->ctm,
 475					val,
 476					sizeof(struct drm_color_ctm),
 477					&replaced);
 478		state->color_mgmt_changed = replaced;
 479		return ret;
 480	} else if (property == config->gamma_lut_property) {
 481		ret = drm_atomic_replace_property_blob_from_id(crtc,
 482					&state->gamma_lut,
 483					val,
 484					-1,
 485					&replaced);
 486		state->color_mgmt_changed = replaced;
 487		return ret;
 
 
 
 
 
 
 
 
 
 
 488	} else if (crtc->funcs->atomic_set_property)
 489		return crtc->funcs->atomic_set_property(crtc, state, property, val);
 490	else
 491		return -EINVAL;
 492
 493	return 0;
 494}
 495EXPORT_SYMBOL(drm_atomic_crtc_set_property);
 496
 497/**
 498 * drm_atomic_crtc_get_property - get property value from CRTC state
 499 * @crtc: the drm CRTC to set a property on
 500 * @state: the state object to get the property value from
 501 * @property: the property to set
 502 * @val: return location for the property value
 503 *
 504 * This function handles generic/core properties and calls out to
 505 * driver's ->atomic_get_property() for driver properties.  To ensure
 506 * consistent behavior you must call this function rather than the
 507 * driver hook directly.
 508 *
 509 * RETURNS:
 510 * Zero on success, error code on failure
 511 */
 512static int
 513drm_atomic_crtc_get_property(struct drm_crtc *crtc,
 514		const struct drm_crtc_state *state,
 515		struct drm_property *property, uint64_t *val)
 516{
 517	struct drm_device *dev = crtc->dev;
 518	struct drm_mode_config *config = &dev->mode_config;
 519
 520	if (property == config->prop_active)
 521		*val = state->active;
 522	else if (property == config->prop_mode_id)
 523		*val = (state->mode_blob) ? state->mode_blob->base.id : 0;
 524	else if (property == config->degamma_lut_property)
 525		*val = (state->degamma_lut) ? state->degamma_lut->base.id : 0;
 526	else if (property == config->ctm_property)
 527		*val = (state->ctm) ? state->ctm->base.id : 0;
 528	else if (property == config->gamma_lut_property)
 529		*val = (state->gamma_lut) ? state->gamma_lut->base.id : 0;
 
 
 530	else if (crtc->funcs->atomic_get_property)
 531		return crtc->funcs->atomic_get_property(crtc, state, property, val);
 532	else
 533		return -EINVAL;
 534
 535	return 0;
 536}
 537
 538/**
 539 * drm_atomic_crtc_check - check crtc state
 540 * @crtc: crtc to check
 541 * @state: crtc state to check
 542 *
 543 * Provides core sanity checks for crtc state.
 544 *
 545 * RETURNS:
 546 * Zero on success, error code on failure
 547 */
 548static int drm_atomic_crtc_check(struct drm_crtc *crtc,
 549		struct drm_crtc_state *state)
 550{
 551	/* NOTE: we explicitly don't enforce constraints such as primary
 552	 * layer covering entire screen, since that is something we want
 553	 * to allow (on hw that supports it).  For hw that does not, it
 554	 * should be checked in driver's crtc->atomic_check() vfunc.
 555	 *
 556	 * TODO: Add generic modeset state checks once we support those.
 557	 */
 558
 559	if (state->active && !state->enable) {
 560		DRM_DEBUG_ATOMIC("[CRTC:%d:%s] active without enabled\n",
 561				 crtc->base.id, crtc->name);
 562		return -EINVAL;
 563	}
 564
 565	/* The state->enable vs. state->mode_blob checks can be WARN_ON,
 566	 * as this is a kernel-internal detail that userspace should never
 567	 * be able to trigger. */
 568	if (drm_core_check_feature(crtc->dev, DRIVER_ATOMIC) &&
 569	    WARN_ON(state->enable && !state->mode_blob)) {
 570		DRM_DEBUG_ATOMIC("[CRTC:%d:%s] enabled without mode blob\n",
 571				 crtc->base.id, crtc->name);
 572		return -EINVAL;
 573	}
 574
 575	if (drm_core_check_feature(crtc->dev, DRIVER_ATOMIC) &&
 576	    WARN_ON(!state->enable && state->mode_blob)) {
 577		DRM_DEBUG_ATOMIC("[CRTC:%d:%s] disabled with mode blob\n",
 578				 crtc->base.id, crtc->name);
 579		return -EINVAL;
 580	}
 581
 582	/*
 583	 * Reject event generation for when a CRTC is off and stays off.
 584	 * It wouldn't be hard to implement this, but userspace has a track
 585	 * record of happily burning through 100% cpu (or worse, crash) when the
 586	 * display pipe is suspended. To avoid all that fun just reject updates
 587	 * that ask for events since likely that indicates a bug in the
 588	 * compositor's drawing loop. This is consistent with the vblank IOCTL
 589	 * and legacy page_flip IOCTL which also reject service on a disabled
 590	 * pipe.
 591	 */
 592	if (state->event && !state->active && !crtc->state->active) {
 593		DRM_DEBUG_ATOMIC("[CRTC:%d] requesting event but off\n",
 594				 crtc->base.id);
 595		return -EINVAL;
 596	}
 597
 598	return 0;
 599}
 600
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 601/**
 602 * drm_atomic_get_plane_state - get plane state
 603 * @state: global atomic state object
 604 * @plane: plane to get state object for
 605 *
 606 * This function returns the plane state for the given plane, allocating it if
 607 * needed. It will also grab the relevant plane lock to make sure that the state
 608 * is consistent.
 609 *
 610 * Returns:
 611 *
 612 * Either the allocated state or the error code encoded into the pointer. When
 613 * the error is EDEADLK then the w/w mutex code has detected a deadlock and the
 614 * entire atomic sequence must be restarted. All other errors are fatal.
 615 */
 616struct drm_plane_state *
 617drm_atomic_get_plane_state(struct drm_atomic_state *state,
 618			  struct drm_plane *plane)
 619{
 620	int ret, index = drm_plane_index(plane);
 621	struct drm_plane_state *plane_state;
 622
 
 
 623	plane_state = drm_atomic_get_existing_plane_state(state, plane);
 624	if (plane_state)
 625		return plane_state;
 626
 627	ret = drm_modeset_lock(&plane->mutex, state->acquire_ctx);
 628	if (ret)
 629		return ERR_PTR(ret);
 630
 631	plane_state = plane->funcs->atomic_duplicate_state(plane);
 632	if (!plane_state)
 633		return ERR_PTR(-ENOMEM);
 634
 635	state->plane_states[index] = plane_state;
 636	state->planes[index] = plane;
 637	plane_state->state = state;
 638
 639	DRM_DEBUG_ATOMIC("Added [PLANE:%d:%s] %p state to %p\n",
 640			 plane->base.id, plane->name, plane_state, state);
 641
 642	if (plane_state->crtc) {
 643		struct drm_crtc_state *crtc_state;
 644
 645		crtc_state = drm_atomic_get_crtc_state(state,
 646						       plane_state->crtc);
 647		if (IS_ERR(crtc_state))
 648			return ERR_CAST(crtc_state);
 649	}
 650
 651	return plane_state;
 652}
 653EXPORT_SYMBOL(drm_atomic_get_plane_state);
 654
 655/**
 656 * drm_atomic_plane_set_property - set property on plane
 657 * @plane: the drm plane to set a property on
 658 * @state: the state object to update with the new property value
 659 * @property: the property to set
 660 * @val: the new property value
 661 *
 662 * Use this instead of calling plane->atomic_set_property directly.
 663 * This function handles generic/core properties and calls out to
 664 * driver's ->atomic_set_property() for driver properties.  To ensure
 665 * consistent behavior you must call this function rather than the
 666 * driver hook directly.
 667 *
 668 * RETURNS:
 669 * Zero on success, error code on failure
 670 */
 671int drm_atomic_plane_set_property(struct drm_plane *plane,
 672		struct drm_plane_state *state, struct drm_property *property,
 673		uint64_t val)
 674{
 675	struct drm_device *dev = plane->dev;
 676	struct drm_mode_config *config = &dev->mode_config;
 677
 678	if (property == config->prop_fb_id) {
 679		struct drm_framebuffer *fb = drm_framebuffer_lookup(dev, val);
 680		drm_atomic_set_fb_for_plane(state, fb);
 681		if (fb)
 682			drm_framebuffer_unreference(fb);
 
 
 
 
 
 
 
 
 
 
 
 683	} else if (property == config->prop_crtc_id) {
 684		struct drm_crtc *crtc = drm_crtc_find(dev, val);
 685		return drm_atomic_set_crtc_for_plane(state, crtc);
 686	} else if (property == config->prop_crtc_x) {
 687		state->crtc_x = U642I64(val);
 688	} else if (property == config->prop_crtc_y) {
 689		state->crtc_y = U642I64(val);
 690	} else if (property == config->prop_crtc_w) {
 691		state->crtc_w = val;
 692	} else if (property == config->prop_crtc_h) {
 693		state->crtc_h = val;
 694	} else if (property == config->prop_src_x) {
 695		state->src_x = val;
 696	} else if (property == config->prop_src_y) {
 697		state->src_y = val;
 698	} else if (property == config->prop_src_w) {
 699		state->src_w = val;
 700	} else if (property == config->prop_src_h) {
 701		state->src_h = val;
 702	} else if (property == config->rotation_property) {
 
 
 703		state->rotation = val;
 
 
 704	} else if (plane->funcs->atomic_set_property) {
 705		return plane->funcs->atomic_set_property(plane, state,
 706				property, val);
 707	} else {
 708		return -EINVAL;
 709	}
 710
 711	return 0;
 712}
 713EXPORT_SYMBOL(drm_atomic_plane_set_property);
 714
 715/**
 716 * drm_atomic_plane_get_property - get property value from plane state
 717 * @plane: the drm plane to set a property on
 718 * @state: the state object to get the property value from
 719 * @property: the property to set
 720 * @val: return location for the property value
 721 *
 722 * This function handles generic/core properties and calls out to
 723 * driver's ->atomic_get_property() for driver properties.  To ensure
 724 * consistent behavior you must call this function rather than the
 725 * driver hook directly.
 726 *
 727 * RETURNS:
 728 * Zero on success, error code on failure
 729 */
 730static int
 731drm_atomic_plane_get_property(struct drm_plane *plane,
 732		const struct drm_plane_state *state,
 733		struct drm_property *property, uint64_t *val)
 734{
 735	struct drm_device *dev = plane->dev;
 736	struct drm_mode_config *config = &dev->mode_config;
 737
 738	if (property == config->prop_fb_id) {
 739		*val = (state->fb) ? state->fb->base.id : 0;
 
 
 740	} else if (property == config->prop_crtc_id) {
 741		*val = (state->crtc) ? state->crtc->base.id : 0;
 742	} else if (property == config->prop_crtc_x) {
 743		*val = I642U64(state->crtc_x);
 744	} else if (property == config->prop_crtc_y) {
 745		*val = I642U64(state->crtc_y);
 746	} else if (property == config->prop_crtc_w) {
 747		*val = state->crtc_w;
 748	} else if (property == config->prop_crtc_h) {
 749		*val = state->crtc_h;
 750	} else if (property == config->prop_src_x) {
 751		*val = state->src_x;
 752	} else if (property == config->prop_src_y) {
 753		*val = state->src_y;
 754	} else if (property == config->prop_src_w) {
 755		*val = state->src_w;
 756	} else if (property == config->prop_src_h) {
 757		*val = state->src_h;
 758	} else if (property == config->rotation_property) {
 759		*val = state->rotation;
 
 
 760	} else if (plane->funcs->atomic_get_property) {
 761		return plane->funcs->atomic_get_property(plane, state, property, val);
 762	} else {
 763		return -EINVAL;
 764	}
 765
 766	return 0;
 767}
 768
 769static bool
 770plane_switching_crtc(struct drm_atomic_state *state,
 771		     struct drm_plane *plane,
 772		     struct drm_plane_state *plane_state)
 773{
 774	if (!plane->state->crtc || !plane_state->crtc)
 775		return false;
 776
 777	if (plane->state->crtc == plane_state->crtc)
 778		return false;
 779
 780	/* This could be refined, but currently there's no helper or driver code
 781	 * to implement direct switching of active planes nor userspace to take
 782	 * advantage of more direct plane switching without the intermediate
 783	 * full OFF state.
 784	 */
 785	return true;
 786}
 787
 788/**
 789 * drm_atomic_plane_check - check plane state
 790 * @plane: plane to check
 791 * @state: plane state to check
 792 *
 793 * Provides core sanity checks for plane state.
 794 *
 795 * RETURNS:
 796 * Zero on success, error code on failure
 797 */
 798static int drm_atomic_plane_check(struct drm_plane *plane,
 799		struct drm_plane_state *state)
 800{
 801	unsigned int fb_width, fb_height;
 802	int ret;
 803
 804	/* either *both* CRTC and FB must be set, or neither */
 805	if (WARN_ON(state->crtc && !state->fb)) {
 806		DRM_DEBUG_ATOMIC("CRTC set but no FB\n");
 807		return -EINVAL;
 808	} else if (WARN_ON(state->fb && !state->crtc)) {
 809		DRM_DEBUG_ATOMIC("FB set but no CRTC\n");
 810		return -EINVAL;
 811	}
 812
 813	/* if disabled, we don't care about the rest of the state: */
 814	if (!state->crtc)
 815		return 0;
 816
 817	/* Check whether this plane is usable on this CRTC */
 818	if (!(plane->possible_crtcs & drm_crtc_mask(state->crtc))) {
 819		DRM_DEBUG_ATOMIC("Invalid crtc for plane\n");
 820		return -EINVAL;
 821	}
 822
 823	/* Check whether this plane supports the fb pixel format. */
 824	ret = drm_plane_check_pixel_format(plane, state->fb->pixel_format);
 825	if (ret) {
 
 826		DRM_DEBUG_ATOMIC("Invalid pixel format %s\n",
 827				 drm_get_format_name(state->fb->pixel_format));
 
 828		return ret;
 829	}
 830
 831	/* Give drivers some help against integer overflows */
 832	if (state->crtc_w > INT_MAX ||
 833	    state->crtc_x > INT_MAX - (int32_t) state->crtc_w ||
 834	    state->crtc_h > INT_MAX ||
 835	    state->crtc_y > INT_MAX - (int32_t) state->crtc_h) {
 836		DRM_DEBUG_ATOMIC("Invalid CRTC coordinates %ux%u+%d+%d\n",
 837				 state->crtc_w, state->crtc_h,
 838				 state->crtc_x, state->crtc_y);
 839		return -ERANGE;
 840	}
 841
 842	fb_width = state->fb->width << 16;
 843	fb_height = state->fb->height << 16;
 844
 845	/* Make sure source coordinates are inside the fb. */
 846	if (state->src_w > fb_width ||
 847	    state->src_x > fb_width - state->src_w ||
 848	    state->src_h > fb_height ||
 849	    state->src_y > fb_height - state->src_h) {
 850		DRM_DEBUG_ATOMIC("Invalid source coordinates "
 851				 "%u.%06ux%u.%06u+%u.%06u+%u.%06u\n",
 852				 state->src_w >> 16, ((state->src_w & 0xffff) * 15625) >> 10,
 853				 state->src_h >> 16, ((state->src_h & 0xffff) * 15625) >> 10,
 854				 state->src_x >> 16, ((state->src_x & 0xffff) * 15625) >> 10,
 855				 state->src_y >> 16, ((state->src_y & 0xffff) * 15625) >> 10);
 856		return -ENOSPC;
 857	}
 858
 859	if (plane_switching_crtc(state->state, plane, state)) {
 860		DRM_DEBUG_ATOMIC("[PLANE:%d:%s] switching CRTC directly\n",
 861				 plane->base.id, plane->name);
 862		return -EINVAL;
 863	}
 864
 865	return 0;
 866}
 867
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 868/**
 869 * drm_atomic_get_connector_state - get connector state
 870 * @state: global atomic state object
 871 * @connector: connector to get state object for
 872 *
 873 * This function returns the connector state for the given connector,
 874 * allocating it if needed. It will also grab the relevant connector lock to
 875 * make sure that the state is consistent.
 876 *
 877 * Returns:
 878 *
 879 * Either the allocated state or the error code encoded into the pointer. When
 880 * the error is EDEADLK then the w/w mutex code has detected a deadlock and the
 881 * entire atomic sequence must be restarted. All other errors are fatal.
 882 */
 883struct drm_connector_state *
 884drm_atomic_get_connector_state(struct drm_atomic_state *state,
 885			  struct drm_connector *connector)
 886{
 887	int ret, index;
 888	struct drm_mode_config *config = &connector->dev->mode_config;
 889	struct drm_connector_state *connector_state;
 890
 
 
 891	ret = drm_modeset_lock(&config->connection_mutex, state->acquire_ctx);
 892	if (ret)
 893		return ERR_PTR(ret);
 894
 895	index = drm_connector_index(connector);
 896
 897	if (index >= state->num_connector) {
 898		struct drm_connector **c;
 899		struct drm_connector_state **cs;
 900		int alloc = max(index + 1, config->num_connector);
 901
 902		c = krealloc(state->connectors, alloc * sizeof(*state->connectors), GFP_KERNEL);
 903		if (!c)
 904			return ERR_PTR(-ENOMEM);
 905
 906		state->connectors = c;
 907		memset(&state->connectors[state->num_connector], 0,
 908		       sizeof(*state->connectors) * (alloc - state->num_connector));
 909
 910		cs = krealloc(state->connector_states, alloc * sizeof(*state->connector_states), GFP_KERNEL);
 911		if (!cs)
 912			return ERR_PTR(-ENOMEM);
 913
 914		state->connector_states = cs;
 915		memset(&state->connector_states[state->num_connector], 0,
 916		       sizeof(*state->connector_states) * (alloc - state->num_connector));
 917		state->num_connector = alloc;
 918	}
 919
 920	if (state->connector_states[index])
 921		return state->connector_states[index];
 922
 923	connector_state = connector->funcs->atomic_duplicate_state(connector);
 924	if (!connector_state)
 925		return ERR_PTR(-ENOMEM);
 926
 927	state->connector_states[index] = connector_state;
 928	state->connectors[index] = connector;
 
 929	connector_state->state = state;
 930
 931	DRM_DEBUG_ATOMIC("Added [CONNECTOR:%d] %p state to %p\n",
 932			 connector->base.id, connector_state, state);
 933
 934	if (connector_state->crtc) {
 935		struct drm_crtc_state *crtc_state;
 936
 937		crtc_state = drm_atomic_get_crtc_state(state,
 938						       connector_state->crtc);
 939		if (IS_ERR(crtc_state))
 940			return ERR_CAST(crtc_state);
 941	}
 942
 943	return connector_state;
 944}
 945EXPORT_SYMBOL(drm_atomic_get_connector_state);
 946
 947/**
 948 * drm_atomic_connector_set_property - set property on connector.
 949 * @connector: the drm connector to set a property on
 950 * @state: the state object to update with the new property value
 951 * @property: the property to set
 952 * @val: the new property value
 953 *
 954 * Use this instead of calling connector->atomic_set_property directly.
 955 * This function handles generic/core properties and calls out to
 956 * driver's ->atomic_set_property() for driver properties.  To ensure
 957 * consistent behavior you must call this function rather than the
 958 * driver hook directly.
 959 *
 960 * RETURNS:
 961 * Zero on success, error code on failure
 962 */
 963int drm_atomic_connector_set_property(struct drm_connector *connector,
 964		struct drm_connector_state *state, struct drm_property *property,
 965		uint64_t val)
 966{
 967	struct drm_device *dev = connector->dev;
 968	struct drm_mode_config *config = &dev->mode_config;
 969
 970	if (property == config->prop_crtc_id) {
 971		struct drm_crtc *crtc = drm_crtc_find(dev, val);
 972		return drm_atomic_set_crtc_for_connector(state, crtc);
 973	} else if (property == config->dpms_property) {
 974		/* setting DPMS property requires special handling, which
 975		 * is done in legacy setprop path for us.  Disallow (for
 976		 * now?) atomic writes to DPMS property:
 977		 */
 978		return -EINVAL;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 979	} else if (connector->funcs->atomic_set_property) {
 980		return connector->funcs->atomic_set_property(connector,
 981				state, property, val);
 982	} else {
 983		return -EINVAL;
 984	}
 
 
 985}
 986EXPORT_SYMBOL(drm_atomic_connector_set_property);
 987
 
 
 
 
 
 
 
 
 
 
 
 
 988/**
 989 * drm_atomic_connector_get_property - get property value from connector state
 990 * @connector: the drm connector to set a property on
 991 * @state: the state object to get the property value from
 992 * @property: the property to set
 993 * @val: return location for the property value
 994 *
 995 * This function handles generic/core properties and calls out to
 996 * driver's ->atomic_get_property() for driver properties.  To ensure
 997 * consistent behavior you must call this function rather than the
 998 * driver hook directly.
 999 *
1000 * RETURNS:
1001 * Zero on success, error code on failure
1002 */
1003static int
1004drm_atomic_connector_get_property(struct drm_connector *connector,
1005		const struct drm_connector_state *state,
1006		struct drm_property *property, uint64_t *val)
1007{
1008	struct drm_device *dev = connector->dev;
1009	struct drm_mode_config *config = &dev->mode_config;
1010
1011	if (property == config->prop_crtc_id) {
1012		*val = (state->crtc) ? state->crtc->base.id : 0;
1013	} else if (property == config->dpms_property) {
1014		*val = connector->dpms;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1015	} else if (connector->funcs->atomic_get_property) {
1016		return connector->funcs->atomic_get_property(connector,
1017				state, property, val);
1018	} else {
1019		return -EINVAL;
1020	}
1021
1022	return 0;
1023}
1024
1025int drm_atomic_get_property(struct drm_mode_object *obj,
1026		struct drm_property *property, uint64_t *val)
1027{
1028	struct drm_device *dev = property->dev;
1029	int ret;
1030
1031	switch (obj->type) {
1032	case DRM_MODE_OBJECT_CONNECTOR: {
1033		struct drm_connector *connector = obj_to_connector(obj);
1034		WARN_ON(!drm_modeset_is_locked(&dev->mode_config.connection_mutex));
1035		ret = drm_atomic_connector_get_property(connector,
1036				connector->state, property, val);
1037		break;
1038	}
1039	case DRM_MODE_OBJECT_CRTC: {
1040		struct drm_crtc *crtc = obj_to_crtc(obj);
1041		WARN_ON(!drm_modeset_is_locked(&crtc->mutex));
1042		ret = drm_atomic_crtc_get_property(crtc,
1043				crtc->state, property, val);
1044		break;
1045	}
1046	case DRM_MODE_OBJECT_PLANE: {
1047		struct drm_plane *plane = obj_to_plane(obj);
1048		WARN_ON(!drm_modeset_is_locked(&plane->mutex));
1049		ret = drm_atomic_plane_get_property(plane,
1050				plane->state, property, val);
1051		break;
1052	}
1053	default:
1054		ret = -EINVAL;
1055		break;
1056	}
1057
1058	return ret;
1059}
1060
1061/**
1062 * drm_atomic_set_crtc_for_plane - set crtc for plane
1063 * @plane_state: the plane whose incoming state to update
1064 * @crtc: crtc to use for the plane
1065 *
1066 * Changing the assigned crtc for a plane requires us to grab the lock and state
1067 * for the new crtc, as needed. This function takes care of all these details
1068 * besides updating the pointer in the state object itself.
1069 *
1070 * Returns:
1071 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
1072 * then the w/w mutex code has detected a deadlock and the entire atomic
1073 * sequence must be restarted. All other errors are fatal.
1074 */
1075int
1076drm_atomic_set_crtc_for_plane(struct drm_plane_state *plane_state,
1077			      struct drm_crtc *crtc)
1078{
1079	struct drm_plane *plane = plane_state->plane;
1080	struct drm_crtc_state *crtc_state;
1081
1082	if (plane_state->crtc) {
1083		crtc_state = drm_atomic_get_crtc_state(plane_state->state,
1084						       plane_state->crtc);
1085		if (WARN_ON(IS_ERR(crtc_state)))
1086			return PTR_ERR(crtc_state);
1087
1088		crtc_state->plane_mask &= ~(1 << drm_plane_index(plane));
1089	}
1090
1091	plane_state->crtc = crtc;
1092
1093	if (crtc) {
1094		crtc_state = drm_atomic_get_crtc_state(plane_state->state,
1095						       crtc);
1096		if (IS_ERR(crtc_state))
1097			return PTR_ERR(crtc_state);
1098		crtc_state->plane_mask |= (1 << drm_plane_index(plane));
1099	}
1100
1101	if (crtc)
1102		DRM_DEBUG_ATOMIC("Link plane state %p to [CRTC:%d:%s]\n",
1103				 plane_state, crtc->base.id, crtc->name);
1104	else
1105		DRM_DEBUG_ATOMIC("Link plane state %p to [NOCRTC]\n",
1106				 plane_state);
1107
1108	return 0;
1109}
1110EXPORT_SYMBOL(drm_atomic_set_crtc_for_plane);
1111
1112/**
1113 * drm_atomic_set_fb_for_plane - set framebuffer for plane
1114 * @plane_state: atomic state object for the plane
1115 * @fb: fb to use for the plane
1116 *
1117 * Changing the assigned framebuffer for a plane requires us to grab a reference
1118 * to the new fb and drop the reference to the old fb, if there is one. This
1119 * function takes care of all these details besides updating the pointer in the
1120 * state object itself.
1121 */
1122void
1123drm_atomic_set_fb_for_plane(struct drm_plane_state *plane_state,
1124			    struct drm_framebuffer *fb)
1125{
1126	if (plane_state->fb)
1127		drm_framebuffer_unreference(plane_state->fb);
1128	if (fb)
1129		drm_framebuffer_reference(fb);
1130	plane_state->fb = fb;
1131
1132	if (fb)
1133		DRM_DEBUG_ATOMIC("Set [FB:%d] for plane state %p\n",
1134				 fb->base.id, plane_state);
1135	else
1136		DRM_DEBUG_ATOMIC("Set [NOFB] for plane state %p\n",
1137				 plane_state);
 
 
1138}
1139EXPORT_SYMBOL(drm_atomic_set_fb_for_plane);
1140
1141/**
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1142 * drm_atomic_set_crtc_for_connector - set crtc for connector
1143 * @conn_state: atomic state object for the connector
1144 * @crtc: crtc to use for the connector
1145 *
1146 * Changing the assigned crtc for a connector requires us to grab the lock and
1147 * state for the new crtc, as needed. This function takes care of all these
1148 * details besides updating the pointer in the state object itself.
1149 *
1150 * Returns:
1151 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
1152 * then the w/w mutex code has detected a deadlock and the entire atomic
1153 * sequence must be restarted. All other errors are fatal.
1154 */
1155int
1156drm_atomic_set_crtc_for_connector(struct drm_connector_state *conn_state,
1157				  struct drm_crtc *crtc)
1158{
1159	struct drm_crtc_state *crtc_state;
1160
1161	if (conn_state->crtc && conn_state->crtc != crtc) {
 
 
 
1162		crtc_state = drm_atomic_get_existing_crtc_state(conn_state->state,
1163								conn_state->crtc);
1164
1165		crtc_state->connector_mask &=
1166			~(1 << drm_connector_index(conn_state->connector));
 
 
 
1167	}
1168
1169	if (crtc) {
1170		crtc_state = drm_atomic_get_crtc_state(conn_state->state, crtc);
1171		if (IS_ERR(crtc_state))
1172			return PTR_ERR(crtc_state);
1173
1174		crtc_state->connector_mask |=
1175			1 << drm_connector_index(conn_state->connector);
1176	}
1177
1178	conn_state->crtc = crtc;
 
1179
1180	if (crtc)
1181		DRM_DEBUG_ATOMIC("Link connector state %p to [CRTC:%d:%s]\n",
1182				 conn_state, crtc->base.id, crtc->name);
1183	else
1184		DRM_DEBUG_ATOMIC("Link connector state %p to [NOCRTC]\n",
1185				 conn_state);
 
1186
1187	return 0;
1188}
1189EXPORT_SYMBOL(drm_atomic_set_crtc_for_connector);
1190
1191/**
1192 * drm_atomic_add_affected_connectors - add connectors for crtc
1193 * @state: atomic state
1194 * @crtc: DRM crtc
1195 *
1196 * This function walks the current configuration and adds all connectors
1197 * currently using @crtc to the atomic configuration @state. Note that this
1198 * function must acquire the connection mutex. This can potentially cause
1199 * unneeded seralization if the update is just for the planes on one crtc. Hence
1200 * drivers and helpers should only call this when really needed (e.g. when a
1201 * full modeset needs to happen due to some change).
1202 *
1203 * Returns:
1204 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
1205 * then the w/w mutex code has detected a deadlock and the entire atomic
1206 * sequence must be restarted. All other errors are fatal.
1207 */
1208int
1209drm_atomic_add_affected_connectors(struct drm_atomic_state *state,
1210				   struct drm_crtc *crtc)
1211{
1212	struct drm_mode_config *config = &state->dev->mode_config;
1213	struct drm_connector *connector;
1214	struct drm_connector_state *conn_state;
1215	int ret;
1216
1217	ret = drm_modeset_lock(&config->connection_mutex, state->acquire_ctx);
1218	if (ret)
1219		return ret;
1220
1221	DRM_DEBUG_ATOMIC("Adding all current connectors for [CRTC:%d:%s] to %p\n",
1222			 crtc->base.id, crtc->name, state);
1223
1224	/*
1225	 * Changed connectors are already in @state, so only need to look at the
1226	 * current configuration.
1227	 */
1228	drm_for_each_connector(connector, state->dev) {
1229		if (connector->state->crtc != crtc)
1230			continue;
1231
1232		conn_state = drm_atomic_get_connector_state(state, connector);
1233		if (IS_ERR(conn_state))
1234			return PTR_ERR(conn_state);
1235	}
1236
1237	return 0;
1238}
1239EXPORT_SYMBOL(drm_atomic_add_affected_connectors);
1240
1241/**
1242 * drm_atomic_add_affected_planes - add planes for crtc
1243 * @state: atomic state
1244 * @crtc: DRM crtc
1245 *
1246 * This function walks the current configuration and adds all planes
1247 * currently used by @crtc to the atomic configuration @state. This is useful
1248 * when an atomic commit also needs to check all currently enabled plane on
1249 * @crtc, e.g. when changing the mode. It's also useful when re-enabling a CRTC
1250 * to avoid special code to force-enable all planes.
1251 *
1252 * Since acquiring a plane state will always also acquire the w/w mutex of the
1253 * current CRTC for that plane (if there is any) adding all the plane states for
1254 * a CRTC will not reduce parallism of atomic updates.
1255 *
1256 * Returns:
1257 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
1258 * then the w/w mutex code has detected a deadlock and the entire atomic
1259 * sequence must be restarted. All other errors are fatal.
1260 */
1261int
1262drm_atomic_add_affected_planes(struct drm_atomic_state *state,
1263			       struct drm_crtc *crtc)
1264{
1265	struct drm_plane *plane;
1266
1267	WARN_ON(!drm_atomic_get_existing_crtc_state(state, crtc));
1268
1269	drm_for_each_plane_mask(plane, state->dev, crtc->state->plane_mask) {
1270		struct drm_plane_state *plane_state =
1271			drm_atomic_get_plane_state(state, plane);
1272
1273		if (IS_ERR(plane_state))
1274			return PTR_ERR(plane_state);
1275	}
1276	return 0;
1277}
1278EXPORT_SYMBOL(drm_atomic_add_affected_planes);
1279
1280/**
1281 * drm_atomic_legacy_backoff - locking backoff for legacy ioctls
1282 * @state: atomic state
1283 *
1284 * This function should be used by legacy entry points which don't understand
1285 * -EDEADLK semantics. For simplicity this one will grab all modeset locks after
1286 * the slowpath completed.
1287 */
1288void drm_atomic_legacy_backoff(struct drm_atomic_state *state)
1289{
 
 
 
1290	int ret;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1291
1292retry:
1293	drm_modeset_backoff(state->acquire_ctx);
1294
1295	ret = drm_modeset_lock_all_ctx(state->dev, state->acquire_ctx);
1296	if (ret)
1297		goto retry;
 
 
 
 
 
 
 
1298}
1299EXPORT_SYMBOL(drm_atomic_legacy_backoff);
1300
1301/**
1302 * drm_atomic_check_only - check whether a given config would work
1303 * @state: atomic configuration to check
1304 *
1305 * Note that this function can return -EDEADLK if the driver needed to acquire
1306 * more locks but encountered a deadlock. The caller must then do the usual w/w
1307 * backoff dance and restart. All other errors are fatal.
1308 *
1309 * Returns:
1310 * 0 on success, negative error code on failure.
1311 */
1312int drm_atomic_check_only(struct drm_atomic_state *state)
1313{
1314	struct drm_device *dev = state->dev;
1315	struct drm_mode_config *config = &dev->mode_config;
1316	struct drm_plane *plane;
1317	struct drm_plane_state *plane_state;
1318	struct drm_crtc *crtc;
1319	struct drm_crtc_state *crtc_state;
1320	int i, ret = 0;
1321
1322	DRM_DEBUG_ATOMIC("checking %p\n", state);
1323
1324	for_each_plane_in_state(state, plane, plane_state, i) {
1325		ret = drm_atomic_plane_check(plane, plane_state);
1326		if (ret) {
1327			DRM_DEBUG_ATOMIC("[PLANE:%d:%s] atomic core check failed\n",
1328					 plane->base.id, plane->name);
1329			return ret;
1330		}
1331	}
1332
1333	for_each_crtc_in_state(state, crtc, crtc_state, i) {
1334		ret = drm_atomic_crtc_check(crtc, crtc_state);
1335		if (ret) {
1336			DRM_DEBUG_ATOMIC("[CRTC:%d:%s] atomic core check failed\n",
1337					 crtc->base.id, crtc->name);
1338			return ret;
1339		}
1340	}
1341
1342	if (config->funcs->atomic_check)
1343		ret = config->funcs->atomic_check(state->dev, state);
1344
1345	if (!state->allow_modeset) {
1346		for_each_crtc_in_state(state, crtc, crtc_state, i) {
1347			if (drm_atomic_crtc_needs_modeset(crtc_state)) {
1348				DRM_DEBUG_ATOMIC("[CRTC:%d:%s] requires full modeset\n",
1349						 crtc->base.id, crtc->name);
1350				return -EINVAL;
1351			}
1352		}
1353	}
1354
1355	return ret;
1356}
1357EXPORT_SYMBOL(drm_atomic_check_only);
1358
1359/**
1360 * drm_atomic_commit - commit configuration atomically
1361 * @state: atomic configuration to check
1362 *
1363 * Note that this function can return -EDEADLK if the driver needed to acquire
1364 * more locks but encountered a deadlock. The caller must then do the usual w/w
1365 * backoff dance and restart. All other errors are fatal.
1366 *
1367 * Also note that on successful execution ownership of @state is transferred
1368 * from the caller of this function to the function itself. The caller must not
1369 * free or in any other way access @state. If the function fails then the caller
1370 * must clean up @state itself.
1371 *
1372 * Returns:
1373 * 0 on success, negative error code on failure.
1374 */
1375int drm_atomic_commit(struct drm_atomic_state *state)
1376{
1377	struct drm_mode_config *config = &state->dev->mode_config;
1378	int ret;
1379
1380	ret = drm_atomic_check_only(state);
1381	if (ret)
1382		return ret;
1383
1384	DRM_DEBUG_ATOMIC("commiting %p\n", state);
1385
1386	return config->funcs->atomic_commit(state->dev, state, false);
1387}
1388EXPORT_SYMBOL(drm_atomic_commit);
1389
1390/**
1391 * drm_atomic_async_commit - atomic&async configuration commit
1392 * @state: atomic configuration to check
1393 *
1394 * Note that this function can return -EDEADLK if the driver needed to acquire
1395 * more locks but encountered a deadlock. The caller must then do the usual w/w
1396 * backoff dance and restart. All other errors are fatal.
1397 *
1398 * Also note that on successful execution ownership of @state is transferred
1399 * from the caller of this function to the function itself. The caller must not
1400 * free or in any other way access @state. If the function fails then the caller
1401 * must clean up @state itself.
1402 *
1403 * Returns:
1404 * 0 on success, negative error code on failure.
1405 */
1406int drm_atomic_async_commit(struct drm_atomic_state *state)
1407{
1408	struct drm_mode_config *config = &state->dev->mode_config;
1409	int ret;
1410
1411	ret = drm_atomic_check_only(state);
1412	if (ret)
1413		return ret;
1414
1415	DRM_DEBUG_ATOMIC("commiting %p asynchronously\n", state);
1416
1417	return config->funcs->atomic_commit(state->dev, state, true);
1418}
1419EXPORT_SYMBOL(drm_atomic_async_commit);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1420
1421/*
1422 * The big monstor ioctl
1423 */
1424
1425static struct drm_pending_vblank_event *create_vblank_event(
1426		struct drm_device *dev, struct drm_file *file_priv, uint64_t user_data)
1427{
1428	struct drm_pending_vblank_event *e = NULL;
1429	int ret;
1430
1431	e = kzalloc(sizeof *e, GFP_KERNEL);
1432	if (!e)
1433		return NULL;
1434
1435	e->event.base.type = DRM_EVENT_FLIP_COMPLETE;
1436	e->event.base.length = sizeof(e->event);
1437	e->event.user_data = user_data;
1438
1439	ret = drm_event_reserve_init(dev, file_priv, &e->base, &e->event.base);
1440	if (ret) {
1441		kfree(e);
1442		return NULL;
1443	}
1444
1445	return e;
1446}
1447
1448static int atomic_set_prop(struct drm_atomic_state *state,
1449		struct drm_mode_object *obj, struct drm_property *prop,
1450		uint64_t prop_value)
1451{
1452	struct drm_mode_object *ref;
1453	int ret;
1454
1455	if (!drm_property_change_valid_get(prop, prop_value, &ref))
1456		return -EINVAL;
1457
1458	switch (obj->type) {
1459	case DRM_MODE_OBJECT_CONNECTOR: {
1460		struct drm_connector *connector = obj_to_connector(obj);
1461		struct drm_connector_state *connector_state;
1462
1463		connector_state = drm_atomic_get_connector_state(state, connector);
1464		if (IS_ERR(connector_state)) {
1465			ret = PTR_ERR(connector_state);
1466			break;
1467		}
1468
1469		ret = drm_atomic_connector_set_property(connector,
1470				connector_state, prop, prop_value);
1471		break;
1472	}
1473	case DRM_MODE_OBJECT_CRTC: {
1474		struct drm_crtc *crtc = obj_to_crtc(obj);
1475		struct drm_crtc_state *crtc_state;
1476
1477		crtc_state = drm_atomic_get_crtc_state(state, crtc);
1478		if (IS_ERR(crtc_state)) {
1479			ret = PTR_ERR(crtc_state);
1480			break;
1481		}
1482
1483		ret = drm_atomic_crtc_set_property(crtc,
1484				crtc_state, prop, prop_value);
1485		break;
1486	}
1487	case DRM_MODE_OBJECT_PLANE: {
1488		struct drm_plane *plane = obj_to_plane(obj);
1489		struct drm_plane_state *plane_state;
1490
1491		plane_state = drm_atomic_get_plane_state(state, plane);
1492		if (IS_ERR(plane_state)) {
1493			ret = PTR_ERR(plane_state);
1494			break;
1495		}
1496
1497		ret = drm_atomic_plane_set_property(plane,
1498				plane_state, prop, prop_value);
1499		break;
1500	}
1501	default:
1502		ret = -EINVAL;
1503		break;
1504	}
1505
1506	drm_property_change_valid_put(prop, ref);
1507	return ret;
1508}
1509
1510/**
1511 * drm_atomic_clean_old_fb -- Unset old_fb pointers and set plane->fb pointers.
1512 *
1513 * @dev: drm device to check.
1514 * @plane_mask: plane mask for planes that were updated.
1515 * @ret: return value, can be -EDEADLK for a retry.
1516 *
1517 * Before doing an update plane->old_fb is set to plane->fb,
1518 * but before dropping the locks old_fb needs to be set to NULL
1519 * and plane->fb updated. This is a common operation for each
1520 * atomic update, so this call is split off as a helper.
1521 */
1522void drm_atomic_clean_old_fb(struct drm_device *dev,
1523			     unsigned plane_mask,
1524			     int ret)
1525{
1526	struct drm_plane *plane;
1527
1528	/* if succeeded, fixup legacy plane crtc/fb ptrs before dropping
1529	 * locks (ie. while it is still safe to deref plane->state).  We
1530	 * need to do this here because the driver entry points cannot
1531	 * distinguish between legacy and atomic ioctls.
1532	 */
1533	drm_for_each_plane_mask(plane, dev, plane_mask) {
1534		if (ret == 0) {
1535			struct drm_framebuffer *new_fb = plane->state->fb;
1536			if (new_fb)
1537				drm_framebuffer_reference(new_fb);
1538			plane->fb = new_fb;
1539			plane->crtc = plane->state->crtc;
1540
1541			if (plane->old_fb)
1542				drm_framebuffer_unreference(plane->old_fb);
1543		}
1544		plane->old_fb = NULL;
1545	}
1546}
1547EXPORT_SYMBOL(drm_atomic_clean_old_fb);
1548
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1549int drm_mode_atomic_ioctl(struct drm_device *dev,
1550			  void *data, struct drm_file *file_priv)
1551{
1552	struct drm_mode_atomic *arg = data;
1553	uint32_t __user *objs_ptr = (uint32_t __user *)(unsigned long)(arg->objs_ptr);
1554	uint32_t __user *count_props_ptr = (uint32_t __user *)(unsigned long)(arg->count_props_ptr);
1555	uint32_t __user *props_ptr = (uint32_t __user *)(unsigned long)(arg->props_ptr);
1556	uint64_t __user *prop_values_ptr = (uint64_t __user *)(unsigned long)(arg->prop_values_ptr);
1557	unsigned int copied_objs, copied_props;
1558	struct drm_atomic_state *state;
1559	struct drm_modeset_acquire_ctx ctx;
1560	struct drm_plane *plane;
1561	struct drm_crtc *crtc;
1562	struct drm_crtc_state *crtc_state;
1563	unsigned plane_mask;
1564	int ret = 0;
1565	unsigned int i, j;
1566
1567	/* disallow for drivers not supporting atomic: */
1568	if (!drm_core_check_feature(dev, DRIVER_ATOMIC))
1569		return -EINVAL;
1570
1571	/* disallow for userspace that has not enabled atomic cap (even
1572	 * though this may be a bit overkill, since legacy userspace
1573	 * wouldn't know how to call this ioctl)
1574	 */
1575	if (!file_priv->atomic)
1576		return -EINVAL;
1577
1578	if (arg->flags & ~DRM_MODE_ATOMIC_FLAGS)
1579		return -EINVAL;
1580
1581	if (arg->reserved)
1582		return -EINVAL;
1583
1584	if ((arg->flags & DRM_MODE_PAGE_FLIP_ASYNC) &&
1585			!dev->mode_config.async_page_flip)
1586		return -EINVAL;
1587
1588	/* can't test and expect an event at the same time. */
1589	if ((arg->flags & DRM_MODE_ATOMIC_TEST_ONLY) &&
1590			(arg->flags & DRM_MODE_PAGE_FLIP_EVENT))
1591		return -EINVAL;
1592
1593	drm_modeset_acquire_init(&ctx, 0);
1594
1595	state = drm_atomic_state_alloc(dev);
1596	if (!state)
1597		return -ENOMEM;
1598
1599	state->acquire_ctx = &ctx;
1600	state->allow_modeset = !!(arg->flags & DRM_MODE_ATOMIC_ALLOW_MODESET);
1601
1602retry:
1603	plane_mask = 0;
1604	copied_objs = 0;
1605	copied_props = 0;
1606
1607	for (i = 0; i < arg->count_objs; i++) {
1608		uint32_t obj_id, count_props;
1609		struct drm_mode_object *obj;
1610
1611		if (get_user(obj_id, objs_ptr + copied_objs)) {
1612			ret = -EFAULT;
1613			goto out;
1614		}
1615
1616		obj = drm_mode_object_find(dev, obj_id, DRM_MODE_OBJECT_ANY);
1617		if (!obj || !obj->properties) {
 
 
 
 
 
 
1618			ret = -ENOENT;
1619			goto out;
1620		}
1621
1622		if (get_user(count_props, count_props_ptr + copied_objs)) {
 
1623			ret = -EFAULT;
1624			goto out;
1625		}
1626
1627		copied_objs++;
1628
1629		for (j = 0; j < count_props; j++) {
1630			uint32_t prop_id;
1631			uint64_t prop_value;
1632			struct drm_property *prop;
1633
1634			if (get_user(prop_id, props_ptr + copied_props)) {
 
1635				ret = -EFAULT;
1636				goto out;
1637			}
1638
1639			prop = drm_property_find(dev, prop_id);
1640			if (!prop) {
 
1641				ret = -ENOENT;
1642				goto out;
1643			}
1644
1645			if (copy_from_user(&prop_value,
1646					   prop_values_ptr + copied_props,
1647					   sizeof(prop_value))) {
 
1648				ret = -EFAULT;
1649				goto out;
1650			}
1651
1652			ret = atomic_set_prop(state, obj, prop, prop_value);
1653			if (ret)
 
1654				goto out;
 
1655
1656			copied_props++;
1657		}
1658
1659		if (obj->type == DRM_MODE_OBJECT_PLANE && count_props &&
1660		    !(arg->flags & DRM_MODE_ATOMIC_TEST_ONLY)) {
1661			plane = obj_to_plane(obj);
1662			plane_mask |= (1 << drm_plane_index(plane));
1663			plane->old_fb = plane->fb;
1664		}
 
1665	}
1666
1667	if (arg->flags & DRM_MODE_PAGE_FLIP_EVENT) {
1668		for_each_crtc_in_state(state, crtc, crtc_state, i) {
1669			struct drm_pending_vblank_event *e;
1670
1671			e = create_vblank_event(dev, file_priv, arg->user_data);
1672			if (!e) {
1673				ret = -ENOMEM;
1674				goto out;
1675			}
1676
1677			crtc_state->event = e;
1678		}
1679	}
1680
1681	if (arg->flags & DRM_MODE_ATOMIC_TEST_ONLY) {
1682		/*
1683		 * Unlike commit, check_only does not clean up state.
1684		 * Below we call drm_atomic_state_free for it.
1685		 */
1686		ret = drm_atomic_check_only(state);
1687	} else if (arg->flags & DRM_MODE_ATOMIC_NONBLOCK) {
1688		ret = drm_atomic_async_commit(state);
1689	} else {
 
 
 
1690		ret = drm_atomic_commit(state);
1691	}
1692
1693out:
1694	drm_atomic_clean_old_fb(dev, plane_mask, ret);
1695
1696	if (ret && arg->flags & DRM_MODE_PAGE_FLIP_EVENT) {
1697		/*
1698		 * TEST_ONLY and PAGE_FLIP_EVENT are mutually exclusive,
1699		 * if they weren't, this code should be called on success
1700		 * for TEST_ONLY too.
1701		 */
1702
1703		for_each_crtc_in_state(state, crtc, crtc_state, i) {
1704			if (!crtc_state->event)
1705				continue;
1706
1707			drm_event_cancel_free(dev, &crtc_state->event->base);
1708		}
1709	}
1710
1711	if (ret == -EDEADLK) {
1712		drm_atomic_state_clear(state);
1713		drm_modeset_backoff(&ctx);
1714		goto retry;
1715	}
1716
1717	if (ret || arg->flags & DRM_MODE_ATOMIC_TEST_ONLY)
1718		drm_atomic_state_free(state);
1719
1720	drm_modeset_drop_locks(&ctx);
1721	drm_modeset_acquire_fini(&ctx);
1722
1723	return ret;
1724}