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#include <drm/drmP.h>
  29#include <drm/drm_atomic.h>
  30#include <drm/drm_plane_helper.h>
  31#include <drm/drm_crtc_helper.h>
  32#include <drm/drm_atomic_helper.h>
  33#include <linux/fence.h>
  34
  35/**
  36 * DOC: overview
  37 *
  38 * This helper library provides implementations of check and commit functions on
  39 * top of the CRTC modeset helper callbacks and the plane helper callbacks. It
  40 * also provides convenience implementations for the atomic state handling
  41 * callbacks for drivers which don't need to subclass the drm core structures to
  42 * add their own additional internal state.
  43 *
  44 * This library also provides default implementations for the check callback in
  45 * drm_atomic_helper_check() and for the commit callback with
  46 * drm_atomic_helper_commit(). But the individual stages and callbacks are
  47 * exposed to allow drivers to mix and match and e.g. use the plane helpers only
  48 * together with a driver private modeset implementation.
  49 *
  50 * This library also provides implementations for all the legacy driver
  51 * interfaces on top of the atomic interface. See drm_atomic_helper_set_config(),
  52 * drm_atomic_helper_disable_plane(), drm_atomic_helper_disable_plane() and the
  53 * various functions to implement set_property callbacks. New drivers must not
  54 * implement these functions themselves but must use the provided helpers.
  55 *
  56 * The atomic helper uses the same function table structures as all other
  57 * modesetting helpers. See the documentation for struct &drm_crtc_helper_funcs,
  58 * struct &drm_encoder_helper_funcs and struct &drm_connector_helper_funcs. It
  59 * also shares the struct &drm_plane_helper_funcs function table with the plane
  60 * helpers.
  61 */
  62static void
  63drm_atomic_helper_plane_changed(struct drm_atomic_state *state,
  64				struct drm_plane_state *plane_state,
  65				struct drm_plane *plane)
  66{
  67	struct drm_crtc_state *crtc_state;
  68
  69	if (plane->state->crtc) {
  70		crtc_state = drm_atomic_get_existing_crtc_state(state,
  71								plane->state->crtc);
  72
  73		if (WARN_ON(!crtc_state))
  74			return;
  75
  76		crtc_state->planes_changed = true;
  77	}
  78
  79	if (plane_state->crtc) {
  80		crtc_state = drm_atomic_get_existing_crtc_state(state,
  81								plane_state->crtc);
  82
  83		if (WARN_ON(!crtc_state))
  84			return;
  85
  86		crtc_state->planes_changed = true;
  87	}
  88}
  89
  90static int handle_conflicting_encoders(struct drm_atomic_state *state,
  91				       bool disable_conflicting_encoders)
  92{
  93	struct drm_connector_state *conn_state;
  94	struct drm_connector *connector;
  95	struct drm_encoder *encoder;
  96	unsigned encoder_mask = 0;
  97	int i, ret;
  98
  99	/*
 100	 * First loop, find all newly assigned encoders from the connectors
 101	 * part of the state. If the same encoder is assigned to multiple
 102	 * connectors bail out.
 103	 */
 104	for_each_connector_in_state(state, connector, conn_state, i) {
 105		const struct drm_connector_helper_funcs *funcs = connector->helper_private;
 106		struct drm_encoder *new_encoder;
 107
 108		if (!conn_state->crtc)
 109			continue;
 110
 111		if (funcs->atomic_best_encoder)
 112			new_encoder = funcs->atomic_best_encoder(connector, conn_state);
 113		else
 114			new_encoder = funcs->best_encoder(connector);
 115
 116		if (new_encoder) {
 117			if (encoder_mask & (1 << drm_encoder_index(new_encoder))) {
 118				DRM_DEBUG_ATOMIC("[ENCODER:%d:%s] on [CONNECTOR:%d:%s] already assigned\n",
 119					new_encoder->base.id, new_encoder->name,
 120					connector->base.id, connector->name);
 121
 122				return -EINVAL;
 123			}
 124
 125			encoder_mask |= 1 << drm_encoder_index(new_encoder);
 126		}
 127	}
 128
 129	if (!encoder_mask)
 130		return 0;
 131
 132	/*
 133	 * Second loop, iterate over all connectors not part of the state.
 134	 *
 135	 * If a conflicting encoder is found and disable_conflicting_encoders
 136	 * is not set, an error is returned. Userspace can provide a solution
 137	 * through the atomic ioctl.
 138	 *
 139	 * If the flag is set conflicting connectors are removed from the crtc
 140	 * and the crtc is disabled if no encoder is left. This preserves
 141	 * compatibility with the legacy set_config behavior.
 142	 */
 143	drm_for_each_connector(connector, state->dev) {
 144		struct drm_crtc_state *crtc_state;
 145
 146		if (drm_atomic_get_existing_connector_state(state, connector))
 147			continue;
 148
 149		encoder = connector->state->best_encoder;
 150		if (!encoder || !(encoder_mask & (1 << drm_encoder_index(encoder))))
 151			continue;
 152
 153		if (!disable_conflicting_encoders) {
 154			DRM_DEBUG_ATOMIC("[ENCODER:%d:%s] in use on [CRTC:%d:%s] by [CONNECTOR:%d:%s]\n",
 155					 encoder->base.id, encoder->name,
 156					 connector->state->crtc->base.id,
 157					 connector->state->crtc->name,
 158					 connector->base.id, connector->name);
 159			return -EINVAL;
 160		}
 161
 162		conn_state = drm_atomic_get_connector_state(state, connector);
 163		if (IS_ERR(conn_state))
 164			return PTR_ERR(conn_state);
 165
 166		DRM_DEBUG_ATOMIC("[ENCODER:%d:%s] in use on [CRTC:%d:%s], disabling [CONNECTOR:%d:%s]\n",
 167				 encoder->base.id, encoder->name,
 168				 conn_state->crtc->base.id, conn_state->crtc->name,
 169				 connector->base.id, connector->name);
 170
 171		crtc_state = drm_atomic_get_existing_crtc_state(state, conn_state->crtc);
 172
 173		ret = drm_atomic_set_crtc_for_connector(conn_state, NULL);
 174		if (ret)
 175			return ret;
 176
 177		if (!crtc_state->connector_mask) {
 178			ret = drm_atomic_set_mode_prop_for_crtc(crtc_state,
 179								NULL);
 180			if (ret < 0)
 181				return ret;
 182
 183			crtc_state->active = false;
 184		}
 185	}
 186
 187	return 0;
 188}
 189
 190static void
 191set_best_encoder(struct drm_atomic_state *state,
 192		 struct drm_connector_state *conn_state,
 193		 struct drm_encoder *encoder)
 194{
 195	struct drm_crtc_state *crtc_state;
 196	struct drm_crtc *crtc;
 197
 198	if (conn_state->best_encoder) {
 199		/* Unset the encoder_mask in the old crtc state. */
 200		crtc = conn_state->connector->state->crtc;
 201
 202		/* A NULL crtc is an error here because we should have
 203		 *  duplicated a NULL best_encoder when crtc was NULL.
 204		 * As an exception restoring duplicated atomic state
 205		 * during resume is allowed, so don't warn when
 206		 * best_encoder is equal to encoder we intend to set.
 207		 */
 208		WARN_ON(!crtc && encoder != conn_state->best_encoder);
 209		if (crtc) {
 210			crtc_state = drm_atomic_get_existing_crtc_state(state, crtc);
 211
 212			crtc_state->encoder_mask &=
 213				~(1 << drm_encoder_index(conn_state->best_encoder));
 214		}
 215	}
 216
 217	if (encoder) {
 218		crtc = conn_state->crtc;
 219		WARN_ON(!crtc);
 220		if (crtc) {
 221			crtc_state = drm_atomic_get_existing_crtc_state(state, crtc);
 222
 223			crtc_state->encoder_mask |=
 224				1 << drm_encoder_index(encoder);
 225		}
 226	}
 227
 228	conn_state->best_encoder = encoder;
 229}
 230
 231static void
 232steal_encoder(struct drm_atomic_state *state,
 233	      struct drm_encoder *encoder)
 234{
 235	struct drm_crtc_state *crtc_state;
 236	struct drm_connector *connector;
 237	struct drm_connector_state *connector_state;
 238	int i;
 239
 240	for_each_connector_in_state(state, connector, connector_state, i) {
 241		struct drm_crtc *encoder_crtc;
 242
 243		if (connector_state->best_encoder != encoder)
 244			continue;
 245
 246		encoder_crtc = connector->state->crtc;
 247
 248		DRM_DEBUG_ATOMIC("[ENCODER:%d:%s] in use on [CRTC:%d:%s], stealing it\n",
 249				 encoder->base.id, encoder->name,
 250				 encoder_crtc->base.id, encoder_crtc->name);
 251
 252		set_best_encoder(state, connector_state, NULL);
 253
 254		crtc_state = drm_atomic_get_existing_crtc_state(state, encoder_crtc);
 255		crtc_state->connectors_changed = true;
 256
 257		return;
 258	}
 259}
 260
 261static int
 262update_connector_routing(struct drm_atomic_state *state,
 263			 struct drm_connector *connector,
 264			 struct drm_connector_state *connector_state)
 265{
 266	const struct drm_connector_helper_funcs *funcs;
 267	struct drm_encoder *new_encoder;
 268	struct drm_crtc_state *crtc_state;
 269
 270	DRM_DEBUG_ATOMIC("Updating routing for [CONNECTOR:%d:%s]\n",
 271			 connector->base.id,
 272			 connector->name);
 273
 274	if (connector->state->crtc != connector_state->crtc) {
 275		if (connector->state->crtc) {
 276			crtc_state = drm_atomic_get_existing_crtc_state(state, connector->state->crtc);
 277			crtc_state->connectors_changed = true;
 278		}
 279
 280		if (connector_state->crtc) {
 281			crtc_state = drm_atomic_get_existing_crtc_state(state, connector_state->crtc);
 282			crtc_state->connectors_changed = true;
 283		}
 284	}
 285
 286	if (!connector_state->crtc) {
 287		DRM_DEBUG_ATOMIC("Disabling [CONNECTOR:%d:%s]\n",
 288				connector->base.id,
 289				connector->name);
 290
 291		set_best_encoder(state, connector_state, NULL);
 292
 293		return 0;
 294	}
 295
 296	funcs = connector->helper_private;
 297
 298	if (funcs->atomic_best_encoder)
 299		new_encoder = funcs->atomic_best_encoder(connector,
 300							 connector_state);
 301	else
 302		new_encoder = funcs->best_encoder(connector);
 303
 304	if (!new_encoder) {
 305		DRM_DEBUG_ATOMIC("No suitable encoder found for [CONNECTOR:%d:%s]\n",
 306				 connector->base.id,
 307				 connector->name);
 308		return -EINVAL;
 309	}
 310
 311	if (!drm_encoder_crtc_ok(new_encoder, connector_state->crtc)) {
 312		DRM_DEBUG_ATOMIC("[ENCODER:%d:%s] incompatible with [CRTC:%d]\n",
 313				 new_encoder->base.id,
 314				 new_encoder->name,
 315				 connector_state->crtc->base.id);
 316		return -EINVAL;
 317	}
 318
 319	if (new_encoder == connector_state->best_encoder) {
 320		set_best_encoder(state, connector_state, new_encoder);
 321
 322		DRM_DEBUG_ATOMIC("[CONNECTOR:%d:%s] keeps [ENCODER:%d:%s], now on [CRTC:%d:%s]\n",
 323				 connector->base.id,
 324				 connector->name,
 325				 new_encoder->base.id,
 326				 new_encoder->name,
 327				 connector_state->crtc->base.id,
 328				 connector_state->crtc->name);
 329
 330		return 0;
 331	}
 332
 333	steal_encoder(state, new_encoder);
 334
 335	set_best_encoder(state, connector_state, new_encoder);
 336
 337	crtc_state = drm_atomic_get_existing_crtc_state(state, connector_state->crtc);
 338	crtc_state->connectors_changed = true;
 339
 340	DRM_DEBUG_ATOMIC("[CONNECTOR:%d:%s] using [ENCODER:%d:%s] on [CRTC:%d:%s]\n",
 341			 connector->base.id,
 342			 connector->name,
 343			 new_encoder->base.id,
 344			 new_encoder->name,
 345			 connector_state->crtc->base.id,
 346			 connector_state->crtc->name);
 347
 348	return 0;
 349}
 350
 351static int
 352mode_fixup(struct drm_atomic_state *state)
 353{
 354	struct drm_crtc *crtc;
 355	struct drm_crtc_state *crtc_state;
 356	struct drm_connector *connector;
 357	struct drm_connector_state *conn_state;
 358	int i;
 359	bool ret;
 360
 361	for_each_crtc_in_state(state, crtc, crtc_state, i) {
 362		if (!crtc_state->mode_changed &&
 363		    !crtc_state->connectors_changed)
 364			continue;
 365
 366		drm_mode_copy(&crtc_state->adjusted_mode, &crtc_state->mode);
 367	}
 368
 369	for_each_connector_in_state(state, connector, conn_state, i) {
 370		const struct drm_encoder_helper_funcs *funcs;
 371		struct drm_encoder *encoder;
 372
 373		WARN_ON(!!conn_state->best_encoder != !!conn_state->crtc);
 374
 375		if (!conn_state->crtc || !conn_state->best_encoder)
 376			continue;
 377
 378		crtc_state = drm_atomic_get_existing_crtc_state(state,
 379								conn_state->crtc);
 380
 381		/*
 382		 * Each encoder has at most one connector (since we always steal
 383		 * it away), so we won't call ->mode_fixup twice.
 384		 */
 385		encoder = conn_state->best_encoder;
 386		funcs = encoder->helper_private;
 387		if (!funcs)
 388			continue;
 389
 390		ret = drm_bridge_mode_fixup(encoder->bridge, &crtc_state->mode,
 391				&crtc_state->adjusted_mode);
 392		if (!ret) {
 393			DRM_DEBUG_ATOMIC("Bridge fixup failed\n");
 394			return -EINVAL;
 395		}
 396
 397		if (funcs->atomic_check) {
 398			ret = funcs->atomic_check(encoder, crtc_state,
 399						  conn_state);
 400			if (ret) {
 401				DRM_DEBUG_ATOMIC("[ENCODER:%d:%s] check failed\n",
 402						 encoder->base.id, encoder->name);
 403				return ret;
 404			}
 405		} else if (funcs->mode_fixup) {
 406			ret = funcs->mode_fixup(encoder, &crtc_state->mode,
 407						&crtc_state->adjusted_mode);
 408			if (!ret) {
 409				DRM_DEBUG_ATOMIC("[ENCODER:%d:%s] fixup failed\n",
 410						 encoder->base.id, encoder->name);
 411				return -EINVAL;
 412			}
 413		}
 414	}
 415
 416	for_each_crtc_in_state(state, crtc, crtc_state, i) {
 417		const struct drm_crtc_helper_funcs *funcs;
 418
 419		if (!crtc_state->mode_changed &&
 420		    !crtc_state->connectors_changed)
 421			continue;
 422
 423		funcs = crtc->helper_private;
 424		if (!funcs->mode_fixup)
 425			continue;
 426
 427		ret = funcs->mode_fixup(crtc, &crtc_state->mode,
 428					&crtc_state->adjusted_mode);
 429		if (!ret) {
 430			DRM_DEBUG_ATOMIC("[CRTC:%d:%s] fixup failed\n",
 431					 crtc->base.id, crtc->name);
 432			return -EINVAL;
 433		}
 434	}
 435
 436	return 0;
 437}
 438
 439/**
 440 * drm_atomic_helper_check_modeset - validate state object for modeset changes
 441 * @dev: DRM device
 442 * @state: the driver state object
 443 *
 444 * Check the state object to see if the requested state is physically possible.
 445 * This does all the crtc and connector related computations for an atomic
 446 * update and adds any additional connectors needed for full modesets and calls
 447 * down into ->mode_fixup functions of the driver backend.
 448 *
 449 * crtc_state->mode_changed is set when the input mode is changed.
 450 * crtc_state->connectors_changed is set when a connector is added or
 451 * removed from the crtc.
 452 * crtc_state->active_changed is set when crtc_state->active changes,
 453 * which is used for dpms.
 454 *
 455 * IMPORTANT:
 456 *
 457 * Drivers which update ->mode_changed (e.g. in their ->atomic_check hooks if a
 458 * plane update can't be done without a full modeset) _must_ call this function
 459 * afterwards after that change. It is permitted to call this function multiple
 460 * times for the same update, e.g. when the ->atomic_check functions depend upon
 461 * the adjusted dotclock for fifo space allocation and watermark computation.
 462 *
 463 * RETURNS
 464 * Zero for success or -errno
 465 */
 466int
 467drm_atomic_helper_check_modeset(struct drm_device *dev,
 468				struct drm_atomic_state *state)
 469{
 470	struct drm_crtc *crtc;
 471	struct drm_crtc_state *crtc_state;
 472	struct drm_connector *connector;
 473	struct drm_connector_state *connector_state;
 474	int i, ret;
 475
 476	for_each_crtc_in_state(state, crtc, crtc_state, i) {
 477		if (!drm_mode_equal(&crtc->state->mode, &crtc_state->mode)) {
 478			DRM_DEBUG_ATOMIC("[CRTC:%d:%s] mode changed\n",
 479					 crtc->base.id, crtc->name);
 480			crtc_state->mode_changed = true;
 481		}
 482
 483		if (crtc->state->enable != crtc_state->enable) {
 484			DRM_DEBUG_ATOMIC("[CRTC:%d:%s] enable changed\n",
 485					 crtc->base.id, crtc->name);
 486
 487			/*
 488			 * For clarity this assignment is done here, but
 489			 * enable == 0 is only true when there are no
 490			 * connectors and a NULL mode.
 491			 *
 492			 * The other way around is true as well. enable != 0
 493			 * iff connectors are attached and a mode is set.
 494			 */
 495			crtc_state->mode_changed = true;
 496			crtc_state->connectors_changed = true;
 497		}
 498	}
 499
 500	ret = handle_conflicting_encoders(state, state->legacy_set_config);
 501	if (ret)
 502		return ret;
 503
 504	for_each_connector_in_state(state, connector, connector_state, i) {
 505		/*
 506		 * This only sets crtc->mode_changed for routing changes,
 507		 * drivers must set crtc->mode_changed themselves when connector
 508		 * properties need to be updated.
 509		 */
 510		ret = update_connector_routing(state, connector,
 511					       connector_state);
 512		if (ret)
 513			return ret;
 514	}
 515
 516	/*
 517	 * After all the routing has been prepared we need to add in any
 518	 * connector which is itself unchanged, but who's crtc changes it's
 519	 * configuration. This must be done before calling mode_fixup in case a
 520	 * crtc only changed its mode but has the same set of connectors.
 521	 */
 522	for_each_crtc_in_state(state, crtc, crtc_state, i) {
 523		bool has_connectors =
 524			!!crtc_state->connector_mask;
 525
 526		/*
 527		 * We must set ->active_changed after walking connectors for
 528		 * otherwise an update that only changes active would result in
 529		 * a full modeset because update_connector_routing force that.
 530		 */
 531		if (crtc->state->active != crtc_state->active) {
 532			DRM_DEBUG_ATOMIC("[CRTC:%d:%s] active changed\n",
 533					 crtc->base.id, crtc->name);
 534			crtc_state->active_changed = true;
 535		}
 536
 537		if (!drm_atomic_crtc_needs_modeset(crtc_state))
 538			continue;
 539
 540		DRM_DEBUG_ATOMIC("[CRTC:%d:%s] needs all connectors, enable: %c, active: %c\n",
 541				 crtc->base.id, crtc->name,
 542				 crtc_state->enable ? 'y' : 'n',
 543				 crtc_state->active ? 'y' : 'n');
 544
 545		ret = drm_atomic_add_affected_connectors(state, crtc);
 546		if (ret != 0)
 547			return ret;
 548
 549		ret = drm_atomic_add_affected_planes(state, crtc);
 550		if (ret != 0)
 551			return ret;
 552
 553		if (crtc_state->enable != has_connectors) {
 554			DRM_DEBUG_ATOMIC("[CRTC:%d:%s] enabled/connectors mismatch\n",
 555					 crtc->base.id, crtc->name);
 556
 557			return -EINVAL;
 558		}
 559	}
 560
 561	return mode_fixup(state);
 562}
 563EXPORT_SYMBOL(drm_atomic_helper_check_modeset);
 564
 565/**
 566 * drm_atomic_helper_check_planes - validate state object for planes changes
 567 * @dev: DRM device
 568 * @state: the driver state object
 569 *
 570 * Check the state object to see if the requested state is physically possible.
 571 * This does all the plane update related checks using by calling into the
 572 * ->atomic_check hooks provided by the driver.
 573 *
 574 * It also sets crtc_state->planes_changed to indicate that a crtc has
 575 * updated planes.
 576 *
 577 * RETURNS
 578 * Zero for success or -errno
 579 */
 580int
 581drm_atomic_helper_check_planes(struct drm_device *dev,
 582			       struct drm_atomic_state *state)
 583{
 584	struct drm_crtc *crtc;
 585	struct drm_crtc_state *crtc_state;
 586	struct drm_plane *plane;
 587	struct drm_plane_state *plane_state;
 588	int i, ret = 0;
 589
 590	for_each_plane_in_state(state, plane, plane_state, i) {
 591		const struct drm_plane_helper_funcs *funcs;
 592
 593		funcs = plane->helper_private;
 594
 595		drm_atomic_helper_plane_changed(state, plane_state, plane);
 596
 597		if (!funcs || !funcs->atomic_check)
 598			continue;
 599
 600		ret = funcs->atomic_check(plane, plane_state);
 601		if (ret) {
 602			DRM_DEBUG_ATOMIC("[PLANE:%d:%s] atomic driver check failed\n",
 603					 plane->base.id, plane->name);
 604			return ret;
 605		}
 606	}
 607
 608	for_each_crtc_in_state(state, crtc, crtc_state, i) {
 609		const struct drm_crtc_helper_funcs *funcs;
 610
 611		funcs = crtc->helper_private;
 612
 613		if (!funcs || !funcs->atomic_check)
 614			continue;
 615
 616		ret = funcs->atomic_check(crtc, state->crtc_states[i]);
 617		if (ret) {
 618			DRM_DEBUG_ATOMIC("[CRTC:%d:%s] atomic driver check failed\n",
 619					 crtc->base.id, crtc->name);
 620			return ret;
 621		}
 622	}
 623
 624	return ret;
 625}
 626EXPORT_SYMBOL(drm_atomic_helper_check_planes);
 627
 628/**
 629 * drm_atomic_helper_check - validate state object
 630 * @dev: DRM device
 631 * @state: the driver state object
 632 *
 633 * Check the state object to see if the requested state is physically possible.
 634 * Only crtcs and planes have check callbacks, so for any additional (global)
 635 * checking that a driver needs it can simply wrap that around this function.
 636 * Drivers without such needs can directly use this as their ->atomic_check()
 637 * callback.
 638 *
 639 * This just wraps the two parts of the state checking for planes and modeset
 640 * state in the default order: First it calls drm_atomic_helper_check_modeset()
 641 * and then drm_atomic_helper_check_planes(). The assumption is that the
 642 * ->atomic_check functions depend upon an updated adjusted_mode.clock to
 643 * e.g. properly compute watermarks.
 644 *
 645 * RETURNS
 646 * Zero for success or -errno
 647 */
 648int drm_atomic_helper_check(struct drm_device *dev,
 649			    struct drm_atomic_state *state)
 650{
 651	int ret;
 652
 653	ret = drm_atomic_helper_check_modeset(dev, state);
 654	if (ret)
 655		return ret;
 656
 657	ret = drm_atomic_helper_check_planes(dev, state);
 658	if (ret)
 659		return ret;
 660
 661	return ret;
 662}
 663EXPORT_SYMBOL(drm_atomic_helper_check);
 664
 665static void
 666disable_outputs(struct drm_device *dev, struct drm_atomic_state *old_state)
 667{
 668	struct drm_connector *connector;
 669	struct drm_connector_state *old_conn_state;
 670	struct drm_crtc *crtc;
 671	struct drm_crtc_state *old_crtc_state;
 672	int i;
 673
 674	for_each_connector_in_state(old_state, connector, old_conn_state, i) {
 675		const struct drm_encoder_helper_funcs *funcs;
 676		struct drm_encoder *encoder;
 677
 678		/* Shut down everything that's in the changeset and currently
 679		 * still on. So need to check the old, saved state. */
 680		if (!old_conn_state->crtc)
 681			continue;
 682
 683		old_crtc_state = drm_atomic_get_existing_crtc_state(old_state,
 684								    old_conn_state->crtc);
 685
 686		if (!old_crtc_state->active ||
 687		    !drm_atomic_crtc_needs_modeset(old_conn_state->crtc->state))
 688			continue;
 689
 690		encoder = old_conn_state->best_encoder;
 691
 692		/* We shouldn't get this far if we didn't previously have
 693		 * an encoder.. but WARN_ON() rather than explode.
 694		 */
 695		if (WARN_ON(!encoder))
 696			continue;
 697
 698		funcs = encoder->helper_private;
 699
 700		DRM_DEBUG_ATOMIC("disabling [ENCODER:%d:%s]\n",
 701				 encoder->base.id, encoder->name);
 702
 703		/*
 704		 * Each encoder has at most one connector (since we always steal
 705		 * it away), so we won't call disable hooks twice.
 706		 */
 707		drm_bridge_disable(encoder->bridge);
 708
 709		/* Right function depends upon target state. */
 710		if (connector->state->crtc && funcs->prepare)
 711			funcs->prepare(encoder);
 712		else if (funcs->disable)
 713			funcs->disable(encoder);
 714		else
 715			funcs->dpms(encoder, DRM_MODE_DPMS_OFF);
 716
 717		drm_bridge_post_disable(encoder->bridge);
 718	}
 719
 720	for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) {
 721		const struct drm_crtc_helper_funcs *funcs;
 722
 723		/* Shut down everything that needs a full modeset. */
 724		if (!drm_atomic_crtc_needs_modeset(crtc->state))
 725			continue;
 726
 727		if (!old_crtc_state->active)
 728			continue;
 729
 730		funcs = crtc->helper_private;
 731
 732		DRM_DEBUG_ATOMIC("disabling [CRTC:%d:%s]\n",
 733				 crtc->base.id, crtc->name);
 734
 735
 736		/* Right function depends upon target state. */
 737		if (crtc->state->enable && funcs->prepare)
 738			funcs->prepare(crtc);
 739		else if (funcs->disable)
 740			funcs->disable(crtc);
 741		else
 742			funcs->dpms(crtc, DRM_MODE_DPMS_OFF);
 743	}
 744}
 745
 746/**
 747 * drm_atomic_helper_update_legacy_modeset_state - update legacy modeset state
 748 * @dev: DRM device
 749 * @old_state: atomic state object with old state structures
 750 *
 751 * This function updates all the various legacy modeset state pointers in
 752 * connectors, encoders and crtcs. It also updates the timestamping constants
 753 * used for precise vblank timestamps by calling
 754 * drm_calc_timestamping_constants().
 755 *
 756 * Drivers can use this for building their own atomic commit if they don't have
 757 * a pure helper-based modeset implementation.
 758 */
 759void
 760drm_atomic_helper_update_legacy_modeset_state(struct drm_device *dev,
 761					      struct drm_atomic_state *old_state)
 762{
 763	struct drm_connector *connector;
 764	struct drm_connector_state *old_conn_state;
 765	struct drm_crtc *crtc;
 766	struct drm_crtc_state *old_crtc_state;
 767	int i;
 768
 769	/* clear out existing links and update dpms */
 770	for_each_connector_in_state(old_state, connector, old_conn_state, i) {
 771		if (connector->encoder) {
 772			WARN_ON(!connector->encoder->crtc);
 773
 774			connector->encoder->crtc = NULL;
 775			connector->encoder = NULL;
 776		}
 777
 778		crtc = connector->state->crtc;
 779		if ((!crtc && old_conn_state->crtc) ||
 780		    (crtc && drm_atomic_crtc_needs_modeset(crtc->state))) {
 781			struct drm_property *dpms_prop =
 782				dev->mode_config.dpms_property;
 783			int mode = DRM_MODE_DPMS_OFF;
 784
 785			if (crtc && crtc->state->active)
 786				mode = DRM_MODE_DPMS_ON;
 787
 788			connector->dpms = mode;
 789			drm_object_property_set_value(&connector->base,
 790						      dpms_prop, mode);
 791		}
 792	}
 793
 794	/* set new links */
 795	for_each_connector_in_state(old_state, connector, old_conn_state, i) {
 796		if (!connector->state->crtc)
 797			continue;
 798
 799		if (WARN_ON(!connector->state->best_encoder))
 800			continue;
 801
 802		connector->encoder = connector->state->best_encoder;
 803		connector->encoder->crtc = connector->state->crtc;
 804	}
 805
 806	/* set legacy state in the crtc structure */
 807	for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) {
 808		struct drm_plane *primary = crtc->primary;
 809
 810		crtc->mode = crtc->state->mode;
 811		crtc->enabled = crtc->state->enable;
 812
 813		if (drm_atomic_get_existing_plane_state(old_state, primary) &&
 814		    primary->state->crtc == crtc) {
 815			crtc->x = primary->state->src_x >> 16;
 816			crtc->y = primary->state->src_y >> 16;
 817		}
 818
 819		if (crtc->state->enable)
 820			drm_calc_timestamping_constants(crtc,
 821							&crtc->state->adjusted_mode);
 822	}
 823}
 824EXPORT_SYMBOL(drm_atomic_helper_update_legacy_modeset_state);
 825
 826static void
 827crtc_set_mode(struct drm_device *dev, struct drm_atomic_state *old_state)
 828{
 829	struct drm_crtc *crtc;
 830	struct drm_crtc_state *old_crtc_state;
 831	struct drm_connector *connector;
 832	struct drm_connector_state *old_conn_state;
 833	int i;
 834
 835	for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) {
 836		const struct drm_crtc_helper_funcs *funcs;
 837
 838		if (!crtc->state->mode_changed)
 839			continue;
 840
 841		funcs = crtc->helper_private;
 842
 843		if (crtc->state->enable && funcs->mode_set_nofb) {
 844			DRM_DEBUG_ATOMIC("modeset on [CRTC:%d:%s]\n",
 845					 crtc->base.id, crtc->name);
 846
 847			funcs->mode_set_nofb(crtc);
 848		}
 849	}
 850
 851	for_each_connector_in_state(old_state, connector, old_conn_state, i) {
 852		const struct drm_encoder_helper_funcs *funcs;
 853		struct drm_crtc_state *new_crtc_state;
 854		struct drm_encoder *encoder;
 855		struct drm_display_mode *mode, *adjusted_mode;
 856
 857		if (!connector->state->best_encoder)
 858			continue;
 859
 860		encoder = connector->state->best_encoder;
 861		funcs = encoder->helper_private;
 862		new_crtc_state = connector->state->crtc->state;
 863		mode = &new_crtc_state->mode;
 864		adjusted_mode = &new_crtc_state->adjusted_mode;
 865
 866		if (!new_crtc_state->mode_changed)
 867			continue;
 868
 869		DRM_DEBUG_ATOMIC("modeset on [ENCODER:%d:%s]\n",
 870				 encoder->base.id, encoder->name);
 871
 872		/*
 873		 * Each encoder has at most one connector (since we always steal
 874		 * it away), so we won't call mode_set hooks twice.
 875		 */
 876		if (funcs->mode_set)
 877			funcs->mode_set(encoder, mode, adjusted_mode);
 878
 879		drm_bridge_mode_set(encoder->bridge, mode, adjusted_mode);
 880	}
 881}
 882
 883/**
 884 * drm_atomic_helper_commit_modeset_disables - modeset commit to disable outputs
 885 * @dev: DRM device
 886 * @old_state: atomic state object with old state structures
 887 *
 888 * This function shuts down all the outputs that need to be shut down and
 889 * prepares them (if required) with the new mode.
 890 *
 891 * For compatibility with legacy crtc helpers this should be called before
 892 * drm_atomic_helper_commit_planes(), which is what the default commit function
 893 * does. But drivers with different needs can group the modeset commits together
 894 * and do the plane commits at the end. This is useful for drivers doing runtime
 895 * PM since planes updates then only happen when the CRTC is actually enabled.
 896 */
 897void drm_atomic_helper_commit_modeset_disables(struct drm_device *dev,
 898					       struct drm_atomic_state *old_state)
 899{
 900	disable_outputs(dev, old_state);
 901
 902	drm_atomic_helper_update_legacy_modeset_state(dev, old_state);
 903
 904	crtc_set_mode(dev, old_state);
 905}
 906EXPORT_SYMBOL(drm_atomic_helper_commit_modeset_disables);
 907
 908/**
 909 * drm_atomic_helper_commit_modeset_enables - modeset commit to enable outputs
 910 * @dev: DRM device
 911 * @old_state: atomic state object with old state structures
 912 *
 913 * This function enables all the outputs with the new configuration which had to
 914 * be turned off for the update.
 915 *
 916 * For compatibility with legacy crtc helpers this should be called after
 917 * drm_atomic_helper_commit_planes(), which is what the default commit function
 918 * does. But drivers with different needs can group the modeset commits together
 919 * and do the plane commits at the end. This is useful for drivers doing runtime
 920 * PM since planes updates then only happen when the CRTC is actually enabled.
 921 */
 922void drm_atomic_helper_commit_modeset_enables(struct drm_device *dev,
 923					      struct drm_atomic_state *old_state)
 924{
 925	struct drm_crtc *crtc;
 926	struct drm_crtc_state *old_crtc_state;
 927	struct drm_connector *connector;
 928	struct drm_connector_state *old_conn_state;
 929	int i;
 930
 931	for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) {
 932		const struct drm_crtc_helper_funcs *funcs;
 933
 934		/* Need to filter out CRTCs where only planes change. */
 935		if (!drm_atomic_crtc_needs_modeset(crtc->state))
 936			continue;
 937
 938		if (!crtc->state->active)
 939			continue;
 940
 941		funcs = crtc->helper_private;
 942
 943		if (crtc->state->enable) {
 944			DRM_DEBUG_ATOMIC("enabling [CRTC:%d:%s]\n",
 945					 crtc->base.id, crtc->name);
 946
 947			if (funcs->enable)
 948				funcs->enable(crtc);
 949			else
 950				funcs->commit(crtc);
 951		}
 952	}
 953
 954	for_each_connector_in_state(old_state, connector, old_conn_state, i) {
 955		const struct drm_encoder_helper_funcs *funcs;
 956		struct drm_encoder *encoder;
 957
 958		if (!connector->state->best_encoder)
 959			continue;
 960
 961		if (!connector->state->crtc->state->active ||
 962		    !drm_atomic_crtc_needs_modeset(connector->state->crtc->state))
 963			continue;
 964
 965		encoder = connector->state->best_encoder;
 966		funcs = encoder->helper_private;
 967
 968		DRM_DEBUG_ATOMIC("enabling [ENCODER:%d:%s]\n",
 969				 encoder->base.id, encoder->name);
 970
 971		/*
 972		 * Each encoder has at most one connector (since we always steal
 973		 * it away), so we won't call enable hooks twice.
 974		 */
 975		drm_bridge_pre_enable(encoder->bridge);
 976
 977		if (funcs->enable)
 978			funcs->enable(encoder);
 979		else
 980			funcs->commit(encoder);
 981
 982		drm_bridge_enable(encoder->bridge);
 983	}
 984}
 985EXPORT_SYMBOL(drm_atomic_helper_commit_modeset_enables);
 986
 987static void wait_for_fences(struct drm_device *dev,
 988			    struct drm_atomic_state *state)
 989{
 990	struct drm_plane *plane;
 991	struct drm_plane_state *plane_state;
 992	int i;
 993
 994	for_each_plane_in_state(state, plane, plane_state, i) {
 995		if (!plane->state->fence)
 996			continue;
 997
 998		WARN_ON(!plane->state->fb);
 999
1000		fence_wait(plane->state->fence, false);
1001		fence_put(plane->state->fence);
1002		plane->state->fence = NULL;
1003	}
1004}
1005
1006/**
1007 * drm_atomic_helper_framebuffer_changed - check if framebuffer has changed
1008 * @dev: DRM device
1009 * @old_state: atomic state object with old state structures
1010 * @crtc: DRM crtc
1011 *
1012 * Checks whether the framebuffer used for this CRTC changes as a result of
1013 * the atomic update.  This is useful for drivers which cannot use
1014 * drm_atomic_helper_wait_for_vblanks() and need to reimplement its
1015 * functionality.
1016 *
1017 * Returns:
1018 * true if the framebuffer changed.
1019 */
1020bool drm_atomic_helper_framebuffer_changed(struct drm_device *dev,
1021					   struct drm_atomic_state *old_state,
1022					   struct drm_crtc *crtc)
1023{
1024	struct drm_plane *plane;
1025	struct drm_plane_state *old_plane_state;
1026	int i;
1027
1028	for_each_plane_in_state(old_state, plane, old_plane_state, i) {
1029		if (plane->state->crtc != crtc &&
1030		    old_plane_state->crtc != crtc)
1031			continue;
1032
1033		if (plane->state->fb != old_plane_state->fb)
1034			return true;
1035	}
1036
1037	return false;
1038}
1039EXPORT_SYMBOL(drm_atomic_helper_framebuffer_changed);
1040
1041/**
1042 * drm_atomic_helper_wait_for_vblanks - wait for vblank on crtcs
1043 * @dev: DRM device
1044 * @old_state: atomic state object with old state structures
1045 *
1046 * Helper to, after atomic commit, wait for vblanks on all effected
1047 * crtcs (ie. before cleaning up old framebuffers using
1048 * drm_atomic_helper_cleanup_planes()). It will only wait on crtcs where the
1049 * framebuffers have actually changed to optimize for the legacy cursor and
1050 * plane update use-case.
1051 */
1052void
1053drm_atomic_helper_wait_for_vblanks(struct drm_device *dev,
1054		struct drm_atomic_state *old_state)
1055{
1056	struct drm_crtc *crtc;
1057	struct drm_crtc_state *old_crtc_state;
1058	int i, ret;
1059
1060	for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) {
1061		/* No one cares about the old state, so abuse it for tracking
1062		 * and store whether we hold a vblank reference (and should do a
1063		 * vblank wait) in the ->enable boolean. */
1064		old_crtc_state->enable = false;
1065
1066		if (!crtc->state->enable)
1067			continue;
1068
1069		/* Legacy cursor ioctls are completely unsynced, and userspace
1070		 * relies on that (by doing tons of cursor updates). */
1071		if (old_state->legacy_cursor_update)
1072			continue;
1073
1074		if (!drm_atomic_helper_framebuffer_changed(dev,
1075				old_state, crtc))
1076			continue;
1077
1078		ret = drm_crtc_vblank_get(crtc);
1079		if (ret != 0)
1080			continue;
1081
1082		old_crtc_state->enable = true;
1083		old_crtc_state->last_vblank_count = drm_crtc_vblank_count(crtc);
1084	}
1085
1086	for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) {
1087		if (!old_crtc_state->enable)
1088			continue;
1089
1090		ret = wait_event_timeout(dev->vblank[i].queue,
1091				old_crtc_state->last_vblank_count !=
1092					drm_crtc_vblank_count(crtc),
1093				msecs_to_jiffies(50));
1094
1095		drm_crtc_vblank_put(crtc);
1096	}
1097}
1098EXPORT_SYMBOL(drm_atomic_helper_wait_for_vblanks);
1099
1100/**
1101 * drm_atomic_helper_commit - commit validated state object
1102 * @dev: DRM device
1103 * @state: the driver state object
1104 * @async: asynchronous commit
1105 *
1106 * This function commits a with drm_atomic_helper_check() pre-validated state
1107 * object. This can still fail when e.g. the framebuffer reservation fails. For
1108 * now this doesn't implement asynchronous commits.
1109 *
1110 * Note that right now this function does not support async commits, and hence
1111 * driver writers must implement their own version for now. Also note that the
1112 * default ordering of how the various stages are called is to match the legacy
1113 * modeset helper library closest. One peculiarity of that is that it doesn't
1114 * mesh well with runtime PM at all.
1115 *
1116 * For drivers supporting runtime PM the recommended sequence is
1117 *
1118 *     drm_atomic_helper_commit_modeset_disables(dev, state);
1119 *
1120 *     drm_atomic_helper_commit_modeset_enables(dev, state);
1121 *
1122 *     drm_atomic_helper_commit_planes(dev, state, true);
1123 *
1124 * See the kerneldoc entries for these three functions for more details.
1125 *
1126 * RETURNS
1127 * Zero for success or -errno.
1128 */
1129int drm_atomic_helper_commit(struct drm_device *dev,
1130			     struct drm_atomic_state *state,
1131			     bool async)
1132{
1133	int ret;
1134
1135	if (async)
1136		return -EBUSY;
1137
1138	ret = drm_atomic_helper_prepare_planes(dev, state);
1139	if (ret)
1140		return ret;
1141
1142	/*
1143	 * This is the point of no return - everything below never fails except
1144	 * when the hw goes bonghits. Which means we can commit the new state on
1145	 * the software side now.
1146	 */
1147
1148	drm_atomic_helper_swap_state(dev, state);
1149
1150	/*
1151	 * Everything below can be run asynchronously without the need to grab
1152	 * any modeset locks at all under one condition: It must be guaranteed
1153	 * that the asynchronous work has either been cancelled (if the driver
1154	 * supports it, which at least requires that the framebuffers get
1155	 * cleaned up with drm_atomic_helper_cleanup_planes()) or completed
1156	 * before the new state gets committed on the software side with
1157	 * drm_atomic_helper_swap_state().
1158	 *
1159	 * This scheme allows new atomic state updates to be prepared and
1160	 * checked in parallel to the asynchronous completion of the previous
1161	 * update. Which is important since compositors need to figure out the
1162	 * composition of the next frame right after having submitted the
1163	 * current layout.
1164	 */
1165
1166	wait_for_fences(dev, state);
1167
1168	drm_atomic_helper_commit_modeset_disables(dev, state);
1169
1170	drm_atomic_helper_commit_planes(dev, state, false);
1171
1172	drm_atomic_helper_commit_modeset_enables(dev, state);
1173
1174	drm_atomic_helper_wait_for_vblanks(dev, state);
1175
1176	drm_atomic_helper_cleanup_planes(dev, state);
1177
1178	drm_atomic_state_free(state);
1179
1180	return 0;
1181}
1182EXPORT_SYMBOL(drm_atomic_helper_commit);
1183
1184/**
1185 * DOC: implementing async commit
1186 *
1187 * For now the atomic helpers don't support async commit directly. If there is
1188 * real need it could be added though, using the dma-buf fence infrastructure
1189 * for generic synchronization with outstanding rendering.
1190 *
1191 * For now drivers have to implement async commit themselves, with the following
1192 * sequence being the recommended one:
1193 *
1194 * 1. Run drm_atomic_helper_prepare_planes() first. This is the only function
1195 * which commit needs to call which can fail, so we want to run it first and
1196 * synchronously.
1197 *
1198 * 2. Synchronize with any outstanding asynchronous commit worker threads which
1199 * might be affected the new state update. This can be done by either cancelling
1200 * or flushing the work items, depending upon whether the driver can deal with
1201 * cancelled updates. Note that it is important to ensure that the framebuffer
1202 * cleanup is still done when cancelling.
1203 *
1204 * For sufficient parallelism it is recommended to have a work item per crtc
1205 * (for updates which don't touch global state) and a global one. Then we only
1206 * need to synchronize with the crtc work items for changed crtcs and the global
1207 * work item, which allows nice concurrent updates on disjoint sets of crtcs.
1208 *
1209 * 3. The software state is updated synchronously with
1210 * drm_atomic_helper_swap_state(). Doing this under the protection of all modeset
1211 * locks means concurrent callers never see inconsistent state. And doing this
1212 * while it's guaranteed that no relevant async worker runs means that async
1213 * workers do not need grab any locks. Actually they must not grab locks, for
1214 * otherwise the work flushing will deadlock.
1215 *
1216 * 4. Schedule a work item to do all subsequent steps, using the split-out
1217 * commit helpers: a) pre-plane commit b) plane commit c) post-plane commit and
1218 * then cleaning up the framebuffers after the old framebuffer is no longer
1219 * being displayed.
1220 */
1221
1222/**
1223 * drm_atomic_helper_prepare_planes - prepare plane resources before commit
1224 * @dev: DRM device
1225 * @state: atomic state object with new state structures
1226 *
1227 * This function prepares plane state, specifically framebuffers, for the new
1228 * configuration. If any failure is encountered this function will call
1229 * ->cleanup_fb on any already successfully prepared framebuffer.
1230 *
1231 * Returns:
1232 * 0 on success, negative error code on failure.
1233 */
1234int drm_atomic_helper_prepare_planes(struct drm_device *dev,
1235				     struct drm_atomic_state *state)
1236{
1237	int nplanes = dev->mode_config.num_total_plane;
1238	int ret, i;
1239
1240	for (i = 0; i < nplanes; i++) {
1241		const struct drm_plane_helper_funcs *funcs;
1242		struct drm_plane *plane = state->planes[i];
1243		struct drm_plane_state *plane_state = state->plane_states[i];
1244
1245		if (!plane)
1246			continue;
1247
1248		funcs = plane->helper_private;
1249
1250		if (funcs->prepare_fb) {
1251			ret = funcs->prepare_fb(plane, plane_state);
1252			if (ret)
1253				goto fail;
1254		}
1255	}
1256
1257	return 0;
1258
1259fail:
1260	for (i--; i >= 0; i--) {
1261		const struct drm_plane_helper_funcs *funcs;
1262		struct drm_plane *plane = state->planes[i];
1263		struct drm_plane_state *plane_state = state->plane_states[i];
1264
1265		if (!plane)
1266			continue;
1267
1268		funcs = plane->helper_private;
1269
1270		if (funcs->cleanup_fb)
1271			funcs->cleanup_fb(plane, plane_state);
1272
1273	}
1274
1275	return ret;
1276}
1277EXPORT_SYMBOL(drm_atomic_helper_prepare_planes);
1278
1279bool plane_crtc_active(struct drm_plane_state *state)
1280{
1281	return state->crtc && state->crtc->state->active;
1282}
1283
1284/**
1285 * drm_atomic_helper_commit_planes - commit plane state
1286 * @dev: DRM device
1287 * @old_state: atomic state object with old state structures
1288 * @active_only: Only commit on active CRTC if set
1289 *
1290 * This function commits the new plane state using the plane and atomic helper
1291 * functions for planes and crtcs. It assumes that the atomic state has already
1292 * been pushed into the relevant object state pointers, since this step can no
1293 * longer fail.
1294 *
1295 * It still requires the global state object @old_state to know which planes and
1296 * crtcs need to be updated though.
1297 *
1298 * Note that this function does all plane updates across all CRTCs in one step.
1299 * If the hardware can't support this approach look at
1300 * drm_atomic_helper_commit_planes_on_crtc() instead.
1301 *
1302 * Plane parameters can be updated by applications while the associated CRTC is
1303 * disabled. The DRM/KMS core will store the parameters in the plane state,
1304 * which will be available to the driver when the CRTC is turned on. As a result
1305 * most drivers don't need to be immediately notified of plane updates for a
1306 * disabled CRTC.
1307 *
1308 * Unless otherwise needed, drivers are advised to set the @active_only
1309 * parameters to true in order not to receive plane update notifications related
1310 * to a disabled CRTC. This avoids the need to manually ignore plane updates in
1311 * driver code when the driver and/or hardware can't or just don't need to deal
1312 * with updates on disabled CRTCs, for example when supporting runtime PM.
1313 *
1314 * The drm_atomic_helper_commit() default implementation only sets @active_only
1315 * to false to most closely match the behaviour of the legacy helpers. This should
1316 * not be copied blindly by drivers.
1317 */
1318void drm_atomic_helper_commit_planes(struct drm_device *dev,
1319				     struct drm_atomic_state *old_state,
1320				     bool active_only)
1321{
1322	struct drm_crtc *crtc;
1323	struct drm_crtc_state *old_crtc_state;
1324	struct drm_plane *plane;
1325	struct drm_plane_state *old_plane_state;
1326	int i;
1327
1328	for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) {
1329		const struct drm_crtc_helper_funcs *funcs;
1330
1331		funcs = crtc->helper_private;
1332
1333		if (!funcs || !funcs->atomic_begin)
1334			continue;
1335
1336		if (active_only && !crtc->state->active)
1337			continue;
1338
1339		funcs->atomic_begin(crtc, old_crtc_state);
1340	}
1341
1342	for_each_plane_in_state(old_state, plane, old_plane_state, i) {
1343		const struct drm_plane_helper_funcs *funcs;
1344		bool disabling;
1345
1346		funcs = plane->helper_private;
1347
1348		if (!funcs)
1349			continue;
1350
1351		disabling = drm_atomic_plane_disabling(plane, old_plane_state);
1352
1353		if (active_only) {
1354			/*
1355			 * Skip planes related to inactive CRTCs. If the plane
1356			 * is enabled use the state of the current CRTC. If the
1357			 * plane is being disabled use the state of the old
1358			 * CRTC to avoid skipping planes being disabled on an
1359			 * active CRTC.
1360			 */
1361			if (!disabling && !plane_crtc_active(plane->state))
1362				continue;
1363			if (disabling && !plane_crtc_active(old_plane_state))
1364				continue;
1365		}
1366
1367		/*
1368		 * Special-case disabling the plane if drivers support it.
1369		 */
1370		if (disabling && funcs->atomic_disable)
1371			funcs->atomic_disable(plane, old_plane_state);
1372		else if (plane->state->crtc || disabling)
1373			funcs->atomic_update(plane, old_plane_state);
1374	}
1375
1376	for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) {
1377		const struct drm_crtc_helper_funcs *funcs;
1378
1379		funcs = crtc->helper_private;
1380
1381		if (!funcs || !funcs->atomic_flush)
1382			continue;
1383
1384		if (active_only && !crtc->state->active)
1385			continue;
1386
1387		funcs->atomic_flush(crtc, old_crtc_state);
1388	}
1389}
1390EXPORT_SYMBOL(drm_atomic_helper_commit_planes);
1391
1392/**
1393 * drm_atomic_helper_commit_planes_on_crtc - commit plane state for a crtc
1394 * @old_crtc_state: atomic state object with the old crtc state
1395 *
1396 * This function commits the new plane state using the plane and atomic helper
1397 * functions for planes on the specific crtc. It assumes that the atomic state
1398 * has already been pushed into the relevant object state pointers, since this
1399 * step can no longer fail.
1400 *
1401 * This function is useful when plane updates should be done crtc-by-crtc
1402 * instead of one global step like drm_atomic_helper_commit_planes() does.
1403 *
1404 * This function can only be savely used when planes are not allowed to move
1405 * between different CRTCs because this function doesn't handle inter-CRTC
1406 * depencies. Callers need to ensure that either no such depencies exist,
1407 * resolve them through ordering of commit calls or through some other means.
1408 */
1409void
1410drm_atomic_helper_commit_planes_on_crtc(struct drm_crtc_state *old_crtc_state)
1411{
1412	const struct drm_crtc_helper_funcs *crtc_funcs;
1413	struct drm_crtc *crtc = old_crtc_state->crtc;
1414	struct drm_atomic_state *old_state = old_crtc_state->state;
1415	struct drm_plane *plane;
1416	unsigned plane_mask;
1417
1418	plane_mask = old_crtc_state->plane_mask;
1419	plane_mask |= crtc->state->plane_mask;
1420
1421	crtc_funcs = crtc->helper_private;
1422	if (crtc_funcs && crtc_funcs->atomic_begin)
1423		crtc_funcs->atomic_begin(crtc, old_crtc_state);
1424
1425	drm_for_each_plane_mask(plane, crtc->dev, plane_mask) {
1426		struct drm_plane_state *old_plane_state =
1427			drm_atomic_get_existing_plane_state(old_state, plane);
1428		const struct drm_plane_helper_funcs *plane_funcs;
1429
1430		plane_funcs = plane->helper_private;
1431
1432		if (!old_plane_state || !plane_funcs)
1433			continue;
1434
1435		WARN_ON(plane->state->crtc && plane->state->crtc != crtc);
1436
1437		if (drm_atomic_plane_disabling(plane, old_plane_state) &&
1438		    plane_funcs->atomic_disable)
1439			plane_funcs->atomic_disable(plane, old_plane_state);
1440		else if (plane->state->crtc ||
1441			 drm_atomic_plane_disabling(plane, old_plane_state))
1442			plane_funcs->atomic_update(plane, old_plane_state);
1443	}
1444
1445	if (crtc_funcs && crtc_funcs->atomic_flush)
1446		crtc_funcs->atomic_flush(crtc, old_crtc_state);
1447}
1448EXPORT_SYMBOL(drm_atomic_helper_commit_planes_on_crtc);
1449
1450/**
1451 * drm_atomic_helper_disable_planes_on_crtc - helper to disable CRTC's planes
1452 * @crtc: CRTC
1453 * @atomic: if set, synchronize with CRTC's atomic_begin/flush hooks
1454 *
1455 * Disables all planes associated with the given CRTC. This can be
1456 * used for instance in the CRTC helper disable callback to disable
1457 * all planes before shutting down the display pipeline.
1458 *
1459 * If the atomic-parameter is set the function calls the CRTC's
1460 * atomic_begin hook before and atomic_flush hook after disabling the
1461 * planes.
1462 *
1463 * It is a bug to call this function without having implemented the
1464 * ->atomic_disable() plane hook.
1465 */
1466void drm_atomic_helper_disable_planes_on_crtc(struct drm_crtc *crtc,
1467					      bool atomic)
1468{
1469	const struct drm_crtc_helper_funcs *crtc_funcs =
1470		crtc->helper_private;
1471	struct drm_plane *plane;
1472
1473	if (atomic && crtc_funcs && crtc_funcs->atomic_begin)
1474		crtc_funcs->atomic_begin(crtc, NULL);
1475
1476	drm_for_each_plane(plane, crtc->dev) {
1477		const struct drm_plane_helper_funcs *plane_funcs =
1478			plane->helper_private;
1479
1480		if (plane->state->crtc != crtc || !plane_funcs)
1481			continue;
1482
1483		WARN_ON(!plane_funcs->atomic_disable);
1484		if (plane_funcs->atomic_disable)
1485			plane_funcs->atomic_disable(plane, NULL);
1486	}
1487
1488	if (atomic && crtc_funcs && crtc_funcs->atomic_flush)
1489		crtc_funcs->atomic_flush(crtc, NULL);
1490}
1491EXPORT_SYMBOL(drm_atomic_helper_disable_planes_on_crtc);
1492
1493/**
1494 * drm_atomic_helper_cleanup_planes - cleanup plane resources after commit
1495 * @dev: DRM device
1496 * @old_state: atomic state object with old state structures
1497 *
1498 * This function cleans up plane state, specifically framebuffers, from the old
1499 * configuration. Hence the old configuration must be perserved in @old_state to
1500 * be able to call this function.
1501 *
1502 * This function must also be called on the new state when the atomic update
1503 * fails at any point after calling drm_atomic_helper_prepare_planes().
1504 */
1505void drm_atomic_helper_cleanup_planes(struct drm_device *dev,
1506				      struct drm_atomic_state *old_state)
1507{
1508	struct drm_plane *plane;
1509	struct drm_plane_state *plane_state;
1510	int i;
1511
1512	for_each_plane_in_state(old_state, plane, plane_state, i) {
1513		const struct drm_plane_helper_funcs *funcs;
1514
1515		funcs = plane->helper_private;
1516
1517		if (funcs->cleanup_fb)
1518			funcs->cleanup_fb(plane, plane_state);
1519	}
1520}
1521EXPORT_SYMBOL(drm_atomic_helper_cleanup_planes);
1522
1523/**
1524 * drm_atomic_helper_swap_state - store atomic state into current sw state
1525 * @dev: DRM device
1526 * @state: atomic state
1527 *
1528 * This function stores the atomic state into the current state pointers in all
1529 * driver objects. It should be called after all failing steps have been done
1530 * and succeeded, but before the actual hardware state is committed.
1531 *
1532 * For cleanup and error recovery the current state for all changed objects will
1533 * be swaped into @state.
1534 *
1535 * With that sequence it fits perfectly into the plane prepare/cleanup sequence:
1536 *
1537 * 1. Call drm_atomic_helper_prepare_planes() with the staged atomic state.
1538 *
1539 * 2. Do any other steps that might fail.
1540 *
1541 * 3. Put the staged state into the current state pointers with this function.
1542 *
1543 * 4. Actually commit the hardware state.
1544 *
1545 * 5. Call drm_atomic_helper_cleanup_planes() with @state, which since step 3
1546 * contains the old state. Also do any other cleanup required with that state.
1547 */
1548void drm_atomic_helper_swap_state(struct drm_device *dev,
1549				  struct drm_atomic_state *state)
1550{
1551	int i;
1552
1553	for (i = 0; i < state->num_connector; i++) {
1554		struct drm_connector *connector = state->connectors[i];
1555
1556		if (!connector)
1557			continue;
1558
1559		connector->state->state = state;
1560		swap(state->connector_states[i], connector->state);
1561		connector->state->state = NULL;
1562	}
1563
1564	for (i = 0; i < dev->mode_config.num_crtc; i++) {
1565		struct drm_crtc *crtc = state->crtcs[i];
1566
1567		if (!crtc)
1568			continue;
1569
1570		crtc->state->state = state;
1571		swap(state->crtc_states[i], crtc->state);
1572		crtc->state->state = NULL;
1573	}
1574
1575	for (i = 0; i < dev->mode_config.num_total_plane; i++) {
1576		struct drm_plane *plane = state->planes[i];
1577
1578		if (!plane)
1579			continue;
1580
1581		plane->state->state = state;
1582		swap(state->plane_states[i], plane->state);
1583		plane->state->state = NULL;
1584	}
1585}
1586EXPORT_SYMBOL(drm_atomic_helper_swap_state);
1587
1588/**
1589 * drm_atomic_helper_update_plane - Helper for primary plane update using atomic
1590 * @plane: plane object to update
1591 * @crtc: owning CRTC of owning plane
1592 * @fb: framebuffer to flip onto plane
1593 * @crtc_x: x offset of primary plane on crtc
1594 * @crtc_y: y offset of primary plane on crtc
1595 * @crtc_w: width of primary plane rectangle on crtc
1596 * @crtc_h: height of primary plane rectangle on crtc
1597 * @src_x: x offset of @fb for panning
1598 * @src_y: y offset of @fb for panning
1599 * @src_w: width of source rectangle in @fb
1600 * @src_h: height of source rectangle in @fb
1601 *
1602 * Provides a default plane update handler using the atomic driver interface.
1603 *
1604 * RETURNS:
1605 * Zero on success, error code on failure
1606 */
1607int drm_atomic_helper_update_plane(struct drm_plane *plane,
1608				   struct drm_crtc *crtc,
1609				   struct drm_framebuffer *fb,
1610				   int crtc_x, int crtc_y,
1611				   unsigned int crtc_w, unsigned int crtc_h,
1612				   uint32_t src_x, uint32_t src_y,
1613				   uint32_t src_w, uint32_t src_h)
1614{
1615	struct drm_atomic_state *state;
1616	struct drm_plane_state *plane_state;
1617	int ret = 0;
1618
1619	state = drm_atomic_state_alloc(plane->dev);
1620	if (!state)
1621		return -ENOMEM;
1622
1623	state->acquire_ctx = drm_modeset_legacy_acquire_ctx(crtc);
1624retry:
1625	plane_state = drm_atomic_get_plane_state(state, plane);
1626	if (IS_ERR(plane_state)) {
1627		ret = PTR_ERR(plane_state);
1628		goto fail;
1629	}
1630
1631	ret = drm_atomic_set_crtc_for_plane(plane_state, crtc);
1632	if (ret != 0)
1633		goto fail;
1634	drm_atomic_set_fb_for_plane(plane_state, fb);
1635	plane_state->crtc_x = crtc_x;
1636	plane_state->crtc_y = crtc_y;
1637	plane_state->crtc_w = crtc_w;
1638	plane_state->crtc_h = crtc_h;
1639	plane_state->src_x = src_x;
1640	plane_state->src_y = src_y;
1641	plane_state->src_w = src_w;
1642	plane_state->src_h = src_h;
1643
1644	if (plane == crtc->cursor)
1645		state->legacy_cursor_update = true;
1646
1647	ret = drm_atomic_commit(state);
1648	if (ret != 0)
1649		goto fail;
1650
1651	/* Driver takes ownership of state on successful commit. */
1652	return 0;
1653fail:
1654	if (ret == -EDEADLK)
1655		goto backoff;
1656
1657	drm_atomic_state_free(state);
1658
1659	return ret;
1660backoff:
1661	drm_atomic_state_clear(state);
1662	drm_atomic_legacy_backoff(state);
1663
1664	/*
1665	 * Someone might have exchanged the framebuffer while we dropped locks
1666	 * in the backoff code. We need to fix up the fb refcount tracking the
1667	 * core does for us.
1668	 */
1669	plane->old_fb = plane->fb;
1670
1671	goto retry;
1672}
1673EXPORT_SYMBOL(drm_atomic_helper_update_plane);
1674
1675/**
1676 * drm_atomic_helper_disable_plane - Helper for primary plane disable using * atomic
1677 * @plane: plane to disable
1678 *
1679 * Provides a default plane disable handler using the atomic driver interface.
1680 *
1681 * RETURNS:
1682 * Zero on success, error code on failure
1683 */
1684int drm_atomic_helper_disable_plane(struct drm_plane *plane)
1685{
1686	struct drm_atomic_state *state;
1687	struct drm_plane_state *plane_state;
1688	int ret = 0;
1689
1690	/*
1691	 * FIXME: Without plane->crtc set we can't get at the implicit legacy
1692	 * acquire context. The real fix will be to wire the acquire ctx through
1693	 * everywhere we need it, but meanwhile prevent chaos by just skipping
1694	 * this noop. The critical case is the cursor ioctls which a) only grab
1695	 * crtc/cursor-plane locks (so we need the crtc to get at the right
1696	 * acquire context) and b) can try to disable the plane multiple times.
1697	 */
1698	if (!plane->crtc)
1699		return 0;
1700
1701	state = drm_atomic_state_alloc(plane->dev);
1702	if (!state)
1703		return -ENOMEM;
1704
1705	state->acquire_ctx = drm_modeset_legacy_acquire_ctx(plane->crtc);
1706retry:
1707	plane_state = drm_atomic_get_plane_state(state, plane);
1708	if (IS_ERR(plane_state)) {
1709		ret = PTR_ERR(plane_state);
1710		goto fail;
1711	}
1712
1713	if (plane_state->crtc && (plane == plane->crtc->cursor))
1714		plane_state->state->legacy_cursor_update = true;
1715
1716	ret = __drm_atomic_helper_disable_plane(plane, plane_state);
1717	if (ret != 0)
1718		goto fail;
1719
1720	ret = drm_atomic_commit(state);
1721	if (ret != 0)
1722		goto fail;
1723
1724	/* Driver takes ownership of state on successful commit. */
1725	return 0;
1726fail:
1727	if (ret == -EDEADLK)
1728		goto backoff;
1729
1730	drm_atomic_state_free(state);
1731
1732	return ret;
1733backoff:
1734	drm_atomic_state_clear(state);
1735	drm_atomic_legacy_backoff(state);
1736
1737	/*
1738	 * Someone might have exchanged the framebuffer while we dropped locks
1739	 * in the backoff code. We need to fix up the fb refcount tracking the
1740	 * core does for us.
1741	 */
1742	plane->old_fb = plane->fb;
1743
1744	goto retry;
1745}
1746EXPORT_SYMBOL(drm_atomic_helper_disable_plane);
1747
1748/* just used from fb-helper and atomic-helper: */
1749int __drm_atomic_helper_disable_plane(struct drm_plane *plane,
1750		struct drm_plane_state *plane_state)
1751{
1752	int ret;
1753
1754	ret = drm_atomic_set_crtc_for_plane(plane_state, NULL);
1755	if (ret != 0)
1756		return ret;
1757
1758	drm_atomic_set_fb_for_plane(plane_state, NULL);
1759	plane_state->crtc_x = 0;
1760	plane_state->crtc_y = 0;
1761	plane_state->crtc_w = 0;
1762	plane_state->crtc_h = 0;
1763	plane_state->src_x = 0;
1764	plane_state->src_y = 0;
1765	plane_state->src_w = 0;
1766	plane_state->src_h = 0;
1767
1768	return 0;
1769}
1770
1771static int update_output_state(struct drm_atomic_state *state,
1772			       struct drm_mode_set *set)
1773{
1774	struct drm_device *dev = set->crtc->dev;
1775	struct drm_crtc *crtc;
1776	struct drm_crtc_state *crtc_state;
1777	struct drm_connector *connector;
1778	struct drm_connector_state *conn_state;
1779	int ret, i;
1780
1781	ret = drm_modeset_lock(&dev->mode_config.connection_mutex,
1782			       state->acquire_ctx);
1783	if (ret)
1784		return ret;
1785
1786	/* First disable all connectors on the target crtc. */
1787	ret = drm_atomic_add_affected_connectors(state, set->crtc);
1788	if (ret)
1789		return ret;
1790
1791	for_each_connector_in_state(state, connector, conn_state, i) {
1792		if (conn_state->crtc == set->crtc) {
1793			ret = drm_atomic_set_crtc_for_connector(conn_state,
1794								NULL);
1795			if (ret)
1796				return ret;
1797		}
1798	}
1799
1800	/* Then set all connectors from set->connectors on the target crtc */
1801	for (i = 0; i < set->num_connectors; i++) {
1802		conn_state = drm_atomic_get_connector_state(state,
1803							    set->connectors[i]);
1804		if (IS_ERR(conn_state))
1805			return PTR_ERR(conn_state);
1806
1807		ret = drm_atomic_set_crtc_for_connector(conn_state,
1808							set->crtc);
1809		if (ret)
1810			return ret;
1811	}
1812
1813	for_each_crtc_in_state(state, crtc, crtc_state, i) {
1814		/* Don't update ->enable for the CRTC in the set_config request,
1815		 * since a mismatch would indicate a bug in the upper layers.
1816		 * The actual modeset code later on will catch any
1817		 * inconsistencies here. */
1818		if (crtc == set->crtc)
1819			continue;
1820
1821		if (!crtc_state->connector_mask) {
1822			ret = drm_atomic_set_mode_prop_for_crtc(crtc_state,
1823								NULL);
1824			if (ret < 0)
1825				return ret;
1826
1827			crtc_state->active = false;
1828		}
1829	}
1830
1831	return 0;
1832}
1833
1834/**
1835 * drm_atomic_helper_set_config - set a new config from userspace
1836 * @set: mode set configuration
1837 *
1838 * Provides a default crtc set_config handler using the atomic driver interface.
1839 *
1840 * Returns:
1841 * Returns 0 on success, negative errno numbers on failure.
1842 */
1843int drm_atomic_helper_set_config(struct drm_mode_set *set)
1844{
1845	struct drm_atomic_state *state;
1846	struct drm_crtc *crtc = set->crtc;
1847	int ret = 0;
1848
1849	state = drm_atomic_state_alloc(crtc->dev);
1850	if (!state)
1851		return -ENOMEM;
1852
1853	state->legacy_set_config = true;
1854	state->acquire_ctx = drm_modeset_legacy_acquire_ctx(crtc);
1855retry:
1856	ret = __drm_atomic_helper_set_config(set, state);
1857	if (ret != 0)
1858		goto fail;
1859
1860	ret = drm_atomic_commit(state);
1861	if (ret != 0)
1862		goto fail;
1863
1864	/* Driver takes ownership of state on successful commit. */
1865	return 0;
1866fail:
1867	if (ret == -EDEADLK)
1868		goto backoff;
1869
1870	drm_atomic_state_free(state);
1871
1872	return ret;
1873backoff:
1874	drm_atomic_state_clear(state);
1875	drm_atomic_legacy_backoff(state);
1876
1877	/*
1878	 * Someone might have exchanged the framebuffer while we dropped locks
1879	 * in the backoff code. We need to fix up the fb refcount tracking the
1880	 * core does for us.
1881	 */
1882	crtc->primary->old_fb = crtc->primary->fb;
1883
1884	goto retry;
1885}
1886EXPORT_SYMBOL(drm_atomic_helper_set_config);
1887
1888/* just used from fb-helper and atomic-helper: */
1889int __drm_atomic_helper_set_config(struct drm_mode_set *set,
1890		struct drm_atomic_state *state)
1891{
1892	struct drm_crtc_state *crtc_state;
1893	struct drm_plane_state *primary_state;
1894	struct drm_crtc *crtc = set->crtc;
1895	int hdisplay, vdisplay;
1896	int ret;
1897
1898	crtc_state = drm_atomic_get_crtc_state(state, crtc);
1899	if (IS_ERR(crtc_state))
1900		return PTR_ERR(crtc_state);
1901
1902	primary_state = drm_atomic_get_plane_state(state, crtc->primary);
1903	if (IS_ERR(primary_state))
1904		return PTR_ERR(primary_state);
1905
1906	if (!set->mode) {
1907		WARN_ON(set->fb);
1908		WARN_ON(set->num_connectors);
1909
1910		ret = drm_atomic_set_mode_for_crtc(crtc_state, NULL);
1911		if (ret != 0)
1912			return ret;
1913
1914		crtc_state->active = false;
1915
1916		ret = drm_atomic_set_crtc_for_plane(primary_state, NULL);
1917		if (ret != 0)
1918			return ret;
1919
1920		drm_atomic_set_fb_for_plane(primary_state, NULL);
1921
1922		goto commit;
1923	}
1924
1925	WARN_ON(!set->fb);
1926	WARN_ON(!set->num_connectors);
1927
1928	ret = drm_atomic_set_mode_for_crtc(crtc_state, set->mode);
1929	if (ret != 0)
1930		return ret;
1931
1932	crtc_state->active = true;
1933
1934	ret = drm_atomic_set_crtc_for_plane(primary_state, crtc);
1935	if (ret != 0)
1936		return ret;
1937
1938	drm_crtc_get_hv_timing(set->mode, &hdisplay, &vdisplay);
1939
1940	drm_atomic_set_fb_for_plane(primary_state, set->fb);
1941	primary_state->crtc_x = 0;
1942	primary_state->crtc_y = 0;
1943	primary_state->crtc_w = hdisplay;
1944	primary_state->crtc_h = vdisplay;
1945	primary_state->src_x = set->x << 16;
1946	primary_state->src_y = set->y << 16;
1947	if (primary_state->rotation & (BIT(DRM_ROTATE_90) | BIT(DRM_ROTATE_270))) {
1948		primary_state->src_w = vdisplay << 16;
1949		primary_state->src_h = hdisplay << 16;
1950	} else {
1951		primary_state->src_w = hdisplay << 16;
1952		primary_state->src_h = vdisplay << 16;
1953	}
1954
1955commit:
1956	ret = update_output_state(state, set);
1957	if (ret)
1958		return ret;
1959
1960	return 0;
1961}
1962
1963/**
1964 * drm_atomic_helper_disable_all - disable all currently active outputs
1965 * @dev: DRM device
1966 * @ctx: lock acquisition context
1967 *
1968 * Loops through all connectors, finding those that aren't turned off and then
1969 * turns them off by setting their DPMS mode to OFF and deactivating the CRTC
1970 * that they are connected to.
1971 *
1972 * This is used for example in suspend/resume to disable all currently active
1973 * functions when suspending.
1974 *
1975 * Note that if callers haven't already acquired all modeset locks this might
1976 * return -EDEADLK, which must be handled by calling drm_modeset_backoff().
1977 *
1978 * Returns:
1979 * 0 on success or a negative error code on failure.
1980 *
1981 * See also:
1982 * drm_atomic_helper_suspend(), drm_atomic_helper_resume()
1983 */
1984int drm_atomic_helper_disable_all(struct drm_device *dev,
1985				  struct drm_modeset_acquire_ctx *ctx)
1986{
1987	struct drm_atomic_state *state;
1988	struct drm_connector *conn;
1989	int err;
1990
1991	state = drm_atomic_state_alloc(dev);
1992	if (!state)
1993		return -ENOMEM;
1994
1995	state->acquire_ctx = ctx;
1996
1997	drm_for_each_connector(conn, dev) {
1998		struct drm_crtc *crtc = conn->state->crtc;
1999		struct drm_crtc_state *crtc_state;
2000
2001		if (!crtc || conn->dpms != DRM_MODE_DPMS_ON)
2002			continue;
2003
2004		crtc_state = drm_atomic_get_crtc_state(state, crtc);
2005		if (IS_ERR(crtc_state)) {
2006			err = PTR_ERR(crtc_state);
2007			goto free;
2008		}
2009
2010		crtc_state->active = false;
2011	}
2012
2013	err = drm_atomic_commit(state);
2014
2015free:
2016	if (err < 0)
2017		drm_atomic_state_free(state);
2018
2019	return err;
2020}
2021EXPORT_SYMBOL(drm_atomic_helper_disable_all);
2022
2023/**
2024 * drm_atomic_helper_suspend - subsystem-level suspend helper
2025 * @dev: DRM device
2026 *
2027 * Duplicates the current atomic state, disables all active outputs and then
2028 * returns a pointer to the original atomic state to the caller. Drivers can
2029 * pass this pointer to the drm_atomic_helper_resume() helper upon resume to
2030 * restore the output configuration that was active at the time the system
2031 * entered suspend.
2032 *
2033 * Note that it is potentially unsafe to use this. The atomic state object
2034 * returned by this function is assumed to be persistent. Drivers must ensure
2035 * that this holds true. Before calling this function, drivers must make sure
2036 * to suspend fbdev emulation so that nothing can be using the device.
2037 *
2038 * Returns:
2039 * A pointer to a copy of the state before suspend on success or an ERR_PTR()-
2040 * encoded error code on failure. Drivers should store the returned atomic
2041 * state object and pass it to the drm_atomic_helper_resume() helper upon
2042 * resume.
2043 *
2044 * See also:
2045 * drm_atomic_helper_duplicate_state(), drm_atomic_helper_disable_all(),
2046 * drm_atomic_helper_resume()
2047 */
2048struct drm_atomic_state *drm_atomic_helper_suspend(struct drm_device *dev)
2049{
2050	struct drm_modeset_acquire_ctx ctx;
2051	struct drm_atomic_state *state;
2052	int err;
2053
2054	drm_modeset_acquire_init(&ctx, 0);
2055
2056retry:
2057	err = drm_modeset_lock_all_ctx(dev, &ctx);
2058	if (err < 0) {
2059		state = ERR_PTR(err);
2060		goto unlock;
2061	}
2062
2063	state = drm_atomic_helper_duplicate_state(dev, &ctx);
2064	if (IS_ERR(state))
2065		goto unlock;
2066
2067	err = drm_atomic_helper_disable_all(dev, &ctx);
2068	if (err < 0) {
2069		drm_atomic_state_free(state);
2070		state = ERR_PTR(err);
2071		goto unlock;
2072	}
2073
2074unlock:
2075	if (PTR_ERR(state) == -EDEADLK) {
2076		drm_modeset_backoff(&ctx);
2077		goto retry;
2078	}
2079
2080	drm_modeset_drop_locks(&ctx);
2081	drm_modeset_acquire_fini(&ctx);
2082	return state;
2083}
2084EXPORT_SYMBOL(drm_atomic_helper_suspend);
2085
2086/**
2087 * drm_atomic_helper_resume - subsystem-level resume helper
2088 * @dev: DRM device
2089 * @state: atomic state to resume to
2090 *
2091 * Calls drm_mode_config_reset() to synchronize hardware and software states,
2092 * grabs all modeset locks and commits the atomic state object. This can be
2093 * used in conjunction with the drm_atomic_helper_suspend() helper to
2094 * implement suspend/resume for drivers that support atomic mode-setting.
2095 *
2096 * Returns:
2097 * 0 on success or a negative error code on failure.
2098 *
2099 * See also:
2100 * drm_atomic_helper_suspend()
2101 */
2102int drm_atomic_helper_resume(struct drm_device *dev,
2103			     struct drm_atomic_state *state)
2104{
2105	struct drm_mode_config *config = &dev->mode_config;
2106	int err;
2107
2108	drm_mode_config_reset(dev);
2109	drm_modeset_lock_all(dev);
2110	state->acquire_ctx = config->acquire_ctx;
2111	err = drm_atomic_commit(state);
2112	drm_modeset_unlock_all(dev);
2113
2114	return err;
2115}
2116EXPORT_SYMBOL(drm_atomic_helper_resume);
2117
2118/**
2119 * drm_atomic_helper_crtc_set_property - helper for crtc properties
2120 * @crtc: DRM crtc
2121 * @property: DRM property
2122 * @val: value of property
2123 *
2124 * Provides a default crtc set_property handler using the atomic driver
2125 * interface.
2126 *
2127 * RETURNS:
2128 * Zero on success, error code on failure
2129 */
2130int
2131drm_atomic_helper_crtc_set_property(struct drm_crtc *crtc,
2132				    struct drm_property *property,
2133				    uint64_t val)
2134{
2135	struct drm_atomic_state *state;
2136	struct drm_crtc_state *crtc_state;
2137	int ret = 0;
2138
2139	state = drm_atomic_state_alloc(crtc->dev);
2140	if (!state)
2141		return -ENOMEM;
2142
2143	/* ->set_property is always called with all locks held. */
2144	state->acquire_ctx = crtc->dev->mode_config.acquire_ctx;
2145retry:
2146	crtc_state = drm_atomic_get_crtc_state(state, crtc);
2147	if (IS_ERR(crtc_state)) {
2148		ret = PTR_ERR(crtc_state);
2149		goto fail;
2150	}
2151
2152	ret = drm_atomic_crtc_set_property(crtc, crtc_state,
2153			property, val);
2154	if (ret)
2155		goto fail;
2156
2157	ret = drm_atomic_commit(state);
2158	if (ret != 0)
2159		goto fail;
2160
2161	/* Driver takes ownership of state on successful commit. */
2162	return 0;
2163fail:
2164	if (ret == -EDEADLK)
2165		goto backoff;
2166
2167	drm_atomic_state_free(state);
2168
2169	return ret;
2170backoff:
2171	drm_atomic_state_clear(state);
2172	drm_atomic_legacy_backoff(state);
2173
2174	goto retry;
2175}
2176EXPORT_SYMBOL(drm_atomic_helper_crtc_set_property);
2177
2178/**
2179 * drm_atomic_helper_plane_set_property - helper for plane properties
2180 * @plane: DRM plane
2181 * @property: DRM property
2182 * @val: value of property
2183 *
2184 * Provides a default plane set_property handler using the atomic driver
2185 * interface.
2186 *
2187 * RETURNS:
2188 * Zero on success, error code on failure
2189 */
2190int
2191drm_atomic_helper_plane_set_property(struct drm_plane *plane,
2192				    struct drm_property *property,
2193				    uint64_t val)
2194{
2195	struct drm_atomic_state *state;
2196	struct drm_plane_state *plane_state;
2197	int ret = 0;
2198
2199	state = drm_atomic_state_alloc(plane->dev);
2200	if (!state)
2201		return -ENOMEM;
2202
2203	/* ->set_property is always called with all locks held. */
2204	state->acquire_ctx = plane->dev->mode_config.acquire_ctx;
2205retry:
2206	plane_state = drm_atomic_get_plane_state(state, plane);
2207	if (IS_ERR(plane_state)) {
2208		ret = PTR_ERR(plane_state);
2209		goto fail;
2210	}
2211
2212	ret = drm_atomic_plane_set_property(plane, plane_state,
2213			property, val);
2214	if (ret)
2215		goto fail;
2216
2217	ret = drm_atomic_commit(state);
2218	if (ret != 0)
2219		goto fail;
2220
2221	/* Driver takes ownership of state on successful commit. */
2222	return 0;
2223fail:
2224	if (ret == -EDEADLK)
2225		goto backoff;
2226
2227	drm_atomic_state_free(state);
2228
2229	return ret;
2230backoff:
2231	drm_atomic_state_clear(state);
2232	drm_atomic_legacy_backoff(state);
2233
2234	goto retry;
2235}
2236EXPORT_SYMBOL(drm_atomic_helper_plane_set_property);
2237
2238/**
2239 * drm_atomic_helper_connector_set_property - helper for connector properties
2240 * @connector: DRM connector
2241 * @property: DRM property
2242 * @val: value of property
2243 *
2244 * Provides a default connector set_property handler using the atomic driver
2245 * interface.
2246 *
2247 * RETURNS:
2248 * Zero on success, error code on failure
2249 */
2250int
2251drm_atomic_helper_connector_set_property(struct drm_connector *connector,
2252				    struct drm_property *property,
2253				    uint64_t val)
2254{
2255	struct drm_atomic_state *state;
2256	struct drm_connector_state *connector_state;
2257	int ret = 0;
2258
2259	state = drm_atomic_state_alloc(connector->dev);
2260	if (!state)
2261		return -ENOMEM;
2262
2263	/* ->set_property is always called with all locks held. */
2264	state->acquire_ctx = connector->dev->mode_config.acquire_ctx;
2265retry:
2266	connector_state = drm_atomic_get_connector_state(state, connector);
2267	if (IS_ERR(connector_state)) {
2268		ret = PTR_ERR(connector_state);
2269		goto fail;
2270	}
2271
2272	ret = drm_atomic_connector_set_property(connector, connector_state,
2273			property, val);
2274	if (ret)
2275		goto fail;
2276
2277	ret = drm_atomic_commit(state);
2278	if (ret != 0)
2279		goto fail;
2280
2281	/* Driver takes ownership of state on successful commit. */
2282	return 0;
2283fail:
2284	if (ret == -EDEADLK)
2285		goto backoff;
2286
2287	drm_atomic_state_free(state);
2288
2289	return ret;
2290backoff:
2291	drm_atomic_state_clear(state);
2292	drm_atomic_legacy_backoff(state);
2293
2294	goto retry;
2295}
2296EXPORT_SYMBOL(drm_atomic_helper_connector_set_property);
2297
2298/**
2299 * drm_atomic_helper_page_flip - execute a legacy page flip
2300 * @crtc: DRM crtc
2301 * @fb: DRM framebuffer
2302 * @event: optional DRM event to signal upon completion
2303 * @flags: flip flags for non-vblank sync'ed updates
2304 *
2305 * Provides a default page flip implementation using the atomic driver interface.
2306 *
2307 * Note that for now so called async page flips (i.e. updates which are not
2308 * synchronized to vblank) are not supported, since the atomic interfaces have
2309 * no provisions for this yet.
2310 *
2311 * Returns:
2312 * Returns 0 on success, negative errno numbers on failure.
2313 */
2314int drm_atomic_helper_page_flip(struct drm_crtc *crtc,
2315				struct drm_framebuffer *fb,
2316				struct drm_pending_vblank_event *event,
2317				uint32_t flags)
2318{
2319	struct drm_plane *plane = crtc->primary;
2320	struct drm_atomic_state *state;
2321	struct drm_plane_state *plane_state;
2322	struct drm_crtc_state *crtc_state;
2323	int ret = 0;
2324
2325	if (flags & DRM_MODE_PAGE_FLIP_ASYNC)
2326		return -EINVAL;
2327
2328	state = drm_atomic_state_alloc(plane->dev);
2329	if (!state)
2330		return -ENOMEM;
2331
2332	state->acquire_ctx = drm_modeset_legacy_acquire_ctx(crtc);
2333retry:
2334	crtc_state = drm_atomic_get_crtc_state(state, crtc);
2335	if (IS_ERR(crtc_state)) {
2336		ret = PTR_ERR(crtc_state);
2337		goto fail;
2338	}
2339	crtc_state->event = event;
2340
2341	plane_state = drm_atomic_get_plane_state(state, plane);
2342	if (IS_ERR(plane_state)) {
2343		ret = PTR_ERR(plane_state);
2344		goto fail;
2345	}
2346
2347	ret = drm_atomic_set_crtc_for_plane(plane_state, crtc);
2348	if (ret != 0)
2349		goto fail;
2350	drm_atomic_set_fb_for_plane(plane_state, fb);
2351
2352	/* Make sure we don't accidentally do a full modeset. */
2353	state->allow_modeset = false;
2354	if (!crtc_state->active) {
2355		DRM_DEBUG_ATOMIC("[CRTC:%d] disabled, rejecting legacy flip\n",
2356				 crtc->base.id);
2357		ret = -EINVAL;
2358		goto fail;
2359	}
2360
2361	ret = drm_atomic_async_commit(state);
2362	if (ret != 0)
2363		goto fail;
2364
2365	/* Driver takes ownership of state on successful async commit. */
2366	return 0;
2367fail:
2368	if (ret == -EDEADLK)
2369		goto backoff;
2370
2371	drm_atomic_state_free(state);
2372
2373	return ret;
2374backoff:
2375	drm_atomic_state_clear(state);
2376	drm_atomic_legacy_backoff(state);
2377
2378	/*
2379	 * Someone might have exchanged the framebuffer while we dropped locks
2380	 * in the backoff code. We need to fix up the fb refcount tracking the
2381	 * core does for us.
2382	 */
2383	plane->old_fb = plane->fb;
2384
2385	goto retry;
2386}
2387EXPORT_SYMBOL(drm_atomic_helper_page_flip);
2388
2389/**
2390 * drm_atomic_helper_connector_dpms() - connector dpms helper implementation
2391 * @connector: affected connector
2392 * @mode: DPMS mode
2393 *
2394 * This is the main helper function provided by the atomic helper framework for
2395 * implementing the legacy DPMS connector interface. It computes the new desired
2396 * ->active state for the corresponding CRTC (if the connector is enabled) and
2397 *  updates it.
2398 *
2399 * Returns:
2400 * Returns 0 on success, negative errno numbers on failure.
2401 */
2402int drm_atomic_helper_connector_dpms(struct drm_connector *connector,
2403				     int mode)
2404{
2405	struct drm_mode_config *config = &connector->dev->mode_config;
2406	struct drm_atomic_state *state;
2407	struct drm_crtc_state *crtc_state;
2408	struct drm_crtc *crtc;
2409	struct drm_connector *tmp_connector;
2410	int ret;
2411	bool active = false;
2412	int old_mode = connector->dpms;
2413
2414	if (mode != DRM_MODE_DPMS_ON)
2415		mode = DRM_MODE_DPMS_OFF;
2416
2417	connector->dpms = mode;
2418	crtc = connector->state->crtc;
2419
2420	if (!crtc)
2421		return 0;
2422
2423	state = drm_atomic_state_alloc(connector->dev);
2424	if (!state)
2425		return -ENOMEM;
2426
2427	state->acquire_ctx = drm_modeset_legacy_acquire_ctx(crtc);
2428retry:
2429	crtc_state = drm_atomic_get_crtc_state(state, crtc);
2430	if (IS_ERR(crtc_state)) {
2431		ret = PTR_ERR(crtc_state);
2432		goto fail;
2433	}
2434
2435	WARN_ON(!drm_modeset_is_locked(&config->connection_mutex));
2436
2437	drm_for_each_connector(tmp_connector, connector->dev) {
2438		if (tmp_connector->state->crtc != crtc)
2439			continue;
2440
2441		if (tmp_connector->dpms == DRM_MODE_DPMS_ON) {
2442			active = true;
2443			break;
2444		}
2445	}
2446	crtc_state->active = active;
2447
2448	ret = drm_atomic_commit(state);
2449	if (ret != 0)
2450		goto fail;
2451
2452	/* Driver takes ownership of state on successful commit. */
2453	return 0;
2454fail:
2455	if (ret == -EDEADLK)
2456		goto backoff;
2457
2458	connector->dpms = old_mode;
2459	drm_atomic_state_free(state);
2460
2461	return ret;
2462backoff:
2463	drm_atomic_state_clear(state);
2464	drm_atomic_legacy_backoff(state);
2465
2466	goto retry;
2467}
2468EXPORT_SYMBOL(drm_atomic_helper_connector_dpms);
2469
2470/**
2471 * DOC: atomic state reset and initialization
2472 *
2473 * Both the drm core and the atomic helpers assume that there is always the full
2474 * and correct atomic software state for all connectors, CRTCs and planes
2475 * available. Which is a bit a problem on driver load and also after system
2476 * suspend. One way to solve this is to have a hardware state read-out
2477 * infrastructure which reconstructs the full software state (e.g. the i915
2478 * driver).
2479 *
2480 * The simpler solution is to just reset the software state to everything off,
2481 * which is easiest to do by calling drm_mode_config_reset(). To facilitate this
2482 * the atomic helpers provide default reset implementations for all hooks.
2483 *
2484 * On the upside the precise state tracking of atomic simplifies system suspend
2485 * and resume a lot. For drivers using drm_mode_config_reset() a complete recipe
2486 * is implemented in drm_atomic_helper_suspend() and drm_atomic_helper_resume().
2487 * For other drivers the building blocks are split out, see the documentation
2488 * for these functions.
2489 */
2490
2491/**
2492 * drm_atomic_helper_crtc_reset - default ->reset hook for CRTCs
2493 * @crtc: drm CRTC
2494 *
2495 * Resets the atomic state for @crtc by freeing the state pointer (which might
2496 * be NULL, e.g. at driver load time) and allocating a new empty state object.
2497 */
2498void drm_atomic_helper_crtc_reset(struct drm_crtc *crtc)
2499{
2500	if (crtc->state) {
2501		drm_property_unreference_blob(crtc->state->mode_blob);
2502		drm_property_unreference_blob(crtc->state->degamma_lut);
2503		drm_property_unreference_blob(crtc->state->ctm);
2504		drm_property_unreference_blob(crtc->state->gamma_lut);
2505	}
2506	kfree(crtc->state);
2507	crtc->state = kzalloc(sizeof(*crtc->state), GFP_KERNEL);
2508
2509	if (crtc->state)
2510		crtc->state->crtc = crtc;
2511}
2512EXPORT_SYMBOL(drm_atomic_helper_crtc_reset);
2513
2514/**
2515 * __drm_atomic_helper_crtc_duplicate_state - copy atomic CRTC state
2516 * @crtc: CRTC object
2517 * @state: atomic CRTC state
2518 *
2519 * Copies atomic state from a CRTC's current state and resets inferred values.
2520 * This is useful for drivers that subclass the CRTC state.
2521 */
2522void __drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc,
2523					      struct drm_crtc_state *state)
2524{
2525	memcpy(state, crtc->state, sizeof(*state));
2526
2527	if (state->mode_blob)
2528		drm_property_reference_blob(state->mode_blob);
2529	if (state->degamma_lut)
2530		drm_property_reference_blob(state->degamma_lut);
2531	if (state->ctm)
2532		drm_property_reference_blob(state->ctm);
2533	if (state->gamma_lut)
2534		drm_property_reference_blob(state->gamma_lut);
2535	state->mode_changed = false;
2536	state->active_changed = false;
2537	state->planes_changed = false;
2538	state->connectors_changed = false;
2539	state->color_mgmt_changed = false;
2540	state->event = NULL;
2541}
2542EXPORT_SYMBOL(__drm_atomic_helper_crtc_duplicate_state);
2543
2544/**
2545 * drm_atomic_helper_crtc_duplicate_state - default state duplicate hook
2546 * @crtc: drm CRTC
2547 *
2548 * Default CRTC state duplicate hook for drivers which don't have their own
2549 * subclassed CRTC state structure.
2550 */
2551struct drm_crtc_state *
2552drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc)
2553{
2554	struct drm_crtc_state *state;
2555
2556	if (WARN_ON(!crtc->state))
2557		return NULL;
2558
2559	state = kmalloc(sizeof(*state), GFP_KERNEL);
2560	if (state)
2561		__drm_atomic_helper_crtc_duplicate_state(crtc, state);
2562
2563	return state;
2564}
2565EXPORT_SYMBOL(drm_atomic_helper_crtc_duplicate_state);
2566
2567/**
2568 * __drm_atomic_helper_crtc_destroy_state - release CRTC state
2569 * @crtc: CRTC object
2570 * @state: CRTC state object to release
2571 *
2572 * Releases all resources stored in the CRTC state without actually freeing
2573 * the memory of the CRTC state. This is useful for drivers that subclass the
2574 * CRTC state.
2575 */
2576void __drm_atomic_helper_crtc_destroy_state(struct drm_crtc *crtc,
2577					    struct drm_crtc_state *state)
2578{
2579	drm_property_unreference_blob(state->mode_blob);
2580	drm_property_unreference_blob(state->degamma_lut);
2581	drm_property_unreference_blob(state->ctm);
2582	drm_property_unreference_blob(state->gamma_lut);
2583}
2584EXPORT_SYMBOL(__drm_atomic_helper_crtc_destroy_state);
2585
2586/**
2587 * drm_atomic_helper_crtc_destroy_state - default state destroy hook
2588 * @crtc: drm CRTC
2589 * @state: CRTC state object to release
2590 *
2591 * Default CRTC state destroy hook for drivers which don't have their own
2592 * subclassed CRTC state structure.
2593 */
2594void drm_atomic_helper_crtc_destroy_state(struct drm_crtc *crtc,
2595					  struct drm_crtc_state *state)
2596{
2597	__drm_atomic_helper_crtc_destroy_state(crtc, state);
2598	kfree(state);
2599}
2600EXPORT_SYMBOL(drm_atomic_helper_crtc_destroy_state);
2601
2602/**
2603 * drm_atomic_helper_plane_reset - default ->reset hook for planes
2604 * @plane: drm plane
2605 *
2606 * Resets the atomic state for @plane by freeing the state pointer (which might
2607 * be NULL, e.g. at driver load time) and allocating a new empty state object.
2608 */
2609void drm_atomic_helper_plane_reset(struct drm_plane *plane)
2610{
2611	if (plane->state && plane->state->fb)
2612		drm_framebuffer_unreference(plane->state->fb);
2613
2614	kfree(plane->state);
2615	plane->state = kzalloc(sizeof(*plane->state), GFP_KERNEL);
2616
2617	if (plane->state) {
2618		plane->state->plane = plane;
2619		plane->state->rotation = BIT(DRM_ROTATE_0);
2620	}
2621}
2622EXPORT_SYMBOL(drm_atomic_helper_plane_reset);
2623
2624/**
2625 * __drm_atomic_helper_plane_duplicate_state - copy atomic plane state
2626 * @plane: plane object
2627 * @state: atomic plane state
2628 *
2629 * Copies atomic state from a plane's current state. This is useful for
2630 * drivers that subclass the plane state.
2631 */
2632void __drm_atomic_helper_plane_duplicate_state(struct drm_plane *plane,
2633					       struct drm_plane_state *state)
2634{
2635	memcpy(state, plane->state, sizeof(*state));
2636
2637	if (state->fb)
2638		drm_framebuffer_reference(state->fb);
2639}
2640EXPORT_SYMBOL(__drm_atomic_helper_plane_duplicate_state);
2641
2642/**
2643 * drm_atomic_helper_plane_duplicate_state - default state duplicate hook
2644 * @plane: drm plane
2645 *
2646 * Default plane state duplicate hook for drivers which don't have their own
2647 * subclassed plane state structure.
2648 */
2649struct drm_plane_state *
2650drm_atomic_helper_plane_duplicate_state(struct drm_plane *plane)
2651{
2652	struct drm_plane_state *state;
2653
2654	if (WARN_ON(!plane->state))
2655		return NULL;
2656
2657	state = kmalloc(sizeof(*state), GFP_KERNEL);
2658	if (state)
2659		__drm_atomic_helper_plane_duplicate_state(plane, state);
2660
2661	return state;
2662}
2663EXPORT_SYMBOL(drm_atomic_helper_plane_duplicate_state);
2664
2665/**
2666 * __drm_atomic_helper_plane_destroy_state - release plane state
2667 * @plane: plane object
2668 * @state: plane state object to release
2669 *
2670 * Releases all resources stored in the plane state without actually freeing
2671 * the memory of the plane state. This is useful for drivers that subclass the
2672 * plane state.
2673 */
2674void __drm_atomic_helper_plane_destroy_state(struct drm_plane *plane,
2675					     struct drm_plane_state *state)
2676{
2677	if (state->fb)
2678		drm_framebuffer_unreference(state->fb);
2679}
2680EXPORT_SYMBOL(__drm_atomic_helper_plane_destroy_state);
2681
2682/**
2683 * drm_atomic_helper_plane_destroy_state - default state destroy hook
2684 * @plane: drm plane
2685 * @state: plane state object to release
2686 *
2687 * Default plane state destroy hook for drivers which don't have their own
2688 * subclassed plane state structure.
2689 */
2690void drm_atomic_helper_plane_destroy_state(struct drm_plane *plane,
2691					   struct drm_plane_state *state)
2692{
2693	__drm_atomic_helper_plane_destroy_state(plane, state);
2694	kfree(state);
2695}
2696EXPORT_SYMBOL(drm_atomic_helper_plane_destroy_state);
2697
2698/**
2699 * __drm_atomic_helper_connector_reset - reset state on connector
2700 * @connector: drm connector
2701 * @conn_state: connector state to assign
2702 *
2703 * Initializes the newly allocated @conn_state and assigns it to
2704 * #connector ->state, usually required when initializing the drivers
2705 * or when called from the ->reset hook.
2706 *
2707 * This is useful for drivers that subclass the connector state.
2708 */
2709void
2710__drm_atomic_helper_connector_reset(struct drm_connector *connector,
2711				    struct drm_connector_state *conn_state)
2712{
2713	if (conn_state)
2714		conn_state->connector = connector;
2715
2716	connector->state = conn_state;
2717}
2718EXPORT_SYMBOL(__drm_atomic_helper_connector_reset);
2719
2720/**
2721 * drm_atomic_helper_connector_reset - default ->reset hook for connectors
2722 * @connector: drm connector
2723 *
2724 * Resets the atomic state for @connector by freeing the state pointer (which
2725 * might be NULL, e.g. at driver load time) and allocating a new empty state
2726 * object.
2727 */
2728void drm_atomic_helper_connector_reset(struct drm_connector *connector)
2729{
2730	struct drm_connector_state *conn_state =
2731		kzalloc(sizeof(*conn_state), GFP_KERNEL);
2732
2733	kfree(connector->state);
2734	__drm_atomic_helper_connector_reset(connector, conn_state);
2735}
2736EXPORT_SYMBOL(drm_atomic_helper_connector_reset);
2737
2738/**
2739 * __drm_atomic_helper_connector_duplicate_state - copy atomic connector state
2740 * @connector: connector object
2741 * @state: atomic connector state
2742 *
2743 * Copies atomic state from a connector's current state. This is useful for
2744 * drivers that subclass the connector state.
2745 */
2746void
2747__drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector,
2748					    struct drm_connector_state *state)
2749{
2750	memcpy(state, connector->state, sizeof(*state));
2751}
2752EXPORT_SYMBOL(__drm_atomic_helper_connector_duplicate_state);
2753
2754/**
2755 * drm_atomic_helper_connector_duplicate_state - default state duplicate hook
2756 * @connector: drm connector
2757 *
2758 * Default connector state duplicate hook for drivers which don't have their own
2759 * subclassed connector state structure.
2760 */
2761struct drm_connector_state *
2762drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector)
2763{
2764	struct drm_connector_state *state;
2765
2766	if (WARN_ON(!connector->state))
2767		return NULL;
2768
2769	state = kmalloc(sizeof(*state), GFP_KERNEL);
2770	if (state)
2771		__drm_atomic_helper_connector_duplicate_state(connector, state);
2772
2773	return state;
2774}
2775EXPORT_SYMBOL(drm_atomic_helper_connector_duplicate_state);
2776
2777/**
2778 * drm_atomic_helper_duplicate_state - duplicate an atomic state object
2779 * @dev: DRM device
2780 * @ctx: lock acquisition context
2781 *
2782 * Makes a copy of the current atomic state by looping over all objects and
2783 * duplicating their respective states. This is used for example by suspend/
2784 * resume support code to save the state prior to suspend such that it can
2785 * be restored upon resume.
2786 *
2787 * Note that this treats atomic state as persistent between save and restore.
2788 * Drivers must make sure that this is possible and won't result in confusion
2789 * or erroneous behaviour.
2790 *
2791 * Note that if callers haven't already acquired all modeset locks this might
2792 * return -EDEADLK, which must be handled by calling drm_modeset_backoff().
2793 *
2794 * Returns:
2795 * A pointer to the copy of the atomic state object on success or an
2796 * ERR_PTR()-encoded error code on failure.
2797 *
2798 * See also:
2799 * drm_atomic_helper_suspend(), drm_atomic_helper_resume()
2800 */
2801struct drm_atomic_state *
2802drm_atomic_helper_duplicate_state(struct drm_device *dev,
2803				  struct drm_modeset_acquire_ctx *ctx)
2804{
2805	struct drm_atomic_state *state;
2806	struct drm_connector *conn;
2807	struct drm_plane *plane;
2808	struct drm_crtc *crtc;
2809	int err = 0;
2810
2811	state = drm_atomic_state_alloc(dev);
2812	if (!state)
2813		return ERR_PTR(-ENOMEM);
2814
2815	state->acquire_ctx = ctx;
2816
2817	drm_for_each_crtc(crtc, dev) {
2818		struct drm_crtc_state *crtc_state;
2819
2820		crtc_state = drm_atomic_get_crtc_state(state, crtc);
2821		if (IS_ERR(crtc_state)) {
2822			err = PTR_ERR(crtc_state);
2823			goto free;
2824		}
2825	}
2826
2827	drm_for_each_plane(plane, dev) {
2828		struct drm_plane_state *plane_state;
2829
2830		plane_state = drm_atomic_get_plane_state(state, plane);
2831		if (IS_ERR(plane_state)) {
2832			err = PTR_ERR(plane_state);
2833			goto free;
2834		}
2835	}
2836
2837	drm_for_each_connector(conn, dev) {
2838		struct drm_connector_state *conn_state;
2839
2840		conn_state = drm_atomic_get_connector_state(state, conn);
2841		if (IS_ERR(conn_state)) {
2842			err = PTR_ERR(conn_state);
2843			goto free;
2844		}
2845	}
2846
2847	/* clear the acquire context so that it isn't accidentally reused */
2848	state->acquire_ctx = NULL;
2849
2850free:
2851	if (err < 0) {
2852		drm_atomic_state_free(state);
2853		state = ERR_PTR(err);
2854	}
2855
2856	return state;
2857}
2858EXPORT_SYMBOL(drm_atomic_helper_duplicate_state);
2859
2860/**
2861 * __drm_atomic_helper_connector_destroy_state - release connector state
2862 * @connector: connector object
2863 * @state: connector state object to release
2864 *
2865 * Releases all resources stored in the connector state without actually
2866 * freeing the memory of the connector state. This is useful for drivers that
2867 * subclass the connector state.
2868 */
2869void
2870__drm_atomic_helper_connector_destroy_state(struct drm_connector *connector,
2871					    struct drm_connector_state *state)
2872{
2873	/*
2874	 * This is currently a placeholder so that drivers that subclass the
2875	 * state will automatically do the right thing if code is ever added
2876	 * to this function.
2877	 */
2878}
2879EXPORT_SYMBOL(__drm_atomic_helper_connector_destroy_state);
2880
2881/**
2882 * drm_atomic_helper_connector_destroy_state - default state destroy hook
2883 * @connector: drm connector
2884 * @state: connector state object to release
2885 *
2886 * Default connector state destroy hook for drivers which don't have their own
2887 * subclassed connector state structure.
2888 */
2889void drm_atomic_helper_connector_destroy_state(struct drm_connector *connector,
2890					  struct drm_connector_state *state)
2891{
2892	__drm_atomic_helper_connector_destroy_state(connector, state);
2893	kfree(state);
2894}
2895EXPORT_SYMBOL(drm_atomic_helper_connector_destroy_state);
2896
2897/**
2898 * drm_atomic_helper_legacy_gamma_set - set the legacy gamma correction table
2899 * @crtc: CRTC object
2900 * @red: red correction table
2901 * @green: green correction table
2902 * @blue: green correction table
2903 * @start:
2904 * @size: size of the tables
2905 *
2906 * Implements support for legacy gamma correction table for drivers
2907 * that support color management through the DEGAMMA_LUT/GAMMA_LUT
2908 * properties.
2909 */
2910void drm_atomic_helper_legacy_gamma_set(struct drm_crtc *crtc,
2911					u16 *red, u16 *green, u16 *blue,
2912					uint32_t start, uint32_t size)
2913{
2914	struct drm_device *dev = crtc->dev;
2915	struct drm_mode_config *config = &dev->mode_config;
2916	struct drm_atomic_state *state;
2917	struct drm_crtc_state *crtc_state;
2918	struct drm_property_blob *blob = NULL;
2919	struct drm_color_lut *blob_data;
2920	int i, ret = 0;
2921
2922	state = drm_atomic_state_alloc(crtc->dev);
2923	if (!state)
2924		return;
2925
2926	blob = drm_property_create_blob(dev,
2927					sizeof(struct drm_color_lut) * size,
2928					NULL);
2929	if (IS_ERR(blob)) {
2930		ret = PTR_ERR(blob);
2931		blob = NULL;
2932		goto fail;
2933	}
2934
2935	/* Prepare GAMMA_LUT with the legacy values. */
2936	blob_data = (struct drm_color_lut *) blob->data;
2937	for (i = 0; i < size; i++) {
2938		blob_data[i].red = red[i];
2939		blob_data[i].green = green[i];
2940		blob_data[i].blue = blue[i];
2941	}
2942
2943	state->acquire_ctx = crtc->dev->mode_config.acquire_ctx;
2944retry:
2945	crtc_state = drm_atomic_get_crtc_state(state, crtc);
2946	if (IS_ERR(crtc_state)) {
2947		ret = PTR_ERR(crtc_state);
2948		goto fail;
2949	}
2950
2951	/* Reset DEGAMMA_LUT and CTM properties. */
2952	ret = drm_atomic_crtc_set_property(crtc, crtc_state,
2953			config->degamma_lut_property, 0);
2954	if (ret)
2955		goto fail;
2956
2957	ret = drm_atomic_crtc_set_property(crtc, crtc_state,
2958			config->ctm_property, 0);
2959	if (ret)
2960		goto fail;
2961
2962	ret = drm_atomic_crtc_set_property(crtc, crtc_state,
2963			config->gamma_lut_property, blob->base.id);
2964	if (ret)
2965		goto fail;
2966
2967	ret = drm_atomic_commit(state);
2968	if (ret)
2969		goto fail;
2970
2971	/* Driver takes ownership of state on successful commit. */
2972
2973	drm_property_unreference_blob(blob);
2974
2975	return;
2976fail:
2977	if (ret == -EDEADLK)
2978		goto backoff;
2979
2980	drm_atomic_state_free(state);
2981	drm_property_unreference_blob(blob);
2982
2983	return;
2984backoff:
2985	drm_atomic_state_clear(state);
2986	drm_atomic_legacy_backoff(state);
2987
2988	goto retry;
2989}
2990EXPORT_SYMBOL(drm_atomic_helper_legacy_gamma_set);