1/*
   2 * Copyright (C) 2014 Red Hat
   3 * Copyright (C) 2014 Intel Corp.
   4 * Copyright (c) 2020-2021, The Linux Foundation. All rights reserved.
   5 *
   6 * Permission is hereby granted, free of charge, to any person obtaining a
   7 * copy of this software and associated documentation files (the "Software"),
   8 * to deal in the Software without restriction, including without limitation
   9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  10 * and/or sell copies of the Software, and to permit persons to whom the
  11 * Software is furnished to do so, subject to the following conditions:
  12 *
  13 * The above copyright notice and this permission notice shall be included in
  14 * all copies or substantial portions of the Software.
  15 *
  16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  19 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
  20 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  21 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  22 * OTHER DEALINGS IN THE SOFTWARE.
  23 *
  24 * Authors:
  25 * Rob Clark <robdclark@gmail.com>
  26 * Daniel Vetter <daniel.vetter@ffwll.ch>
  27 */
  28
  29
  30#include <linux/sync_file.h>
  31
  32#include <drm/drm_atomic.h>
  33#include <drm/drm_atomic_uapi.h>
  34#include <drm/drm_blend.h>
  35#include <drm/drm_bridge.h>
  36#include <drm/drm_debugfs.h>
  37#include <drm/drm_device.h>
  38#include <drm/drm_drv.h>
  39#include <drm/drm_file.h>
  40#include <drm/drm_fourcc.h>
  41#include <drm/drm_framebuffer.h>
  42#include <drm/drm_mode.h>
  43#include <drm/drm_print.h>
  44#include <drm/drm_writeback.h>
  45
  46#include "drm_crtc_internal.h"
  47#include "drm_internal.h"
  48
  49void __drm_crtc_commit_free(struct kref *kref)
  50{
  51	struct drm_crtc_commit *commit =
  52		container_of(kref, struct drm_crtc_commit, ref);
  53
  54	kfree(commit);
  55}
  56EXPORT_SYMBOL(__drm_crtc_commit_free);
  57
  58/**
  59 * drm_crtc_commit_wait - Waits for a commit to complete
  60 * @commit: &drm_crtc_commit to wait for
  61 *
  62 * Waits for a given &drm_crtc_commit to be programmed into the
  63 * hardware and flipped to.
  64 *
  65 * Returns:
  66 *
  67 * 0 on success, a negative error code otherwise.
  68 */
  69int drm_crtc_commit_wait(struct drm_crtc_commit *commit)
  70{
  71	unsigned long timeout = 10 * HZ;
  72	int ret;
  73
  74	if (!commit)
  75		return 0;
  76
  77	ret = wait_for_completion_timeout(&commit->hw_done, timeout);
  78	if (!ret) {
  79		drm_err(commit->crtc->dev, "hw_done timed out\n");
  80		return -ETIMEDOUT;
  81	}
  82
  83	/*
  84	 * Currently no support for overwriting flips, hence
  85	 * stall for previous one to execute completely.
  86	 */
  87	ret = wait_for_completion_timeout(&commit->flip_done, timeout);
  88	if (!ret) {
  89		drm_err(commit->crtc->dev, "flip_done timed out\n");
  90		return -ETIMEDOUT;
  91	}
  92
  93	return 0;
  94}
  95EXPORT_SYMBOL(drm_crtc_commit_wait);
  96
  97/**
  98 * drm_atomic_state_default_release -
  99 * release memory initialized by drm_atomic_state_init
 100 * @state: atomic state
 101 *
 102 * Free all the memory allocated by drm_atomic_state_init.
 103 * This should only be used by drivers which are still subclassing
 104 * &drm_atomic_state and haven't switched to &drm_private_state yet.
 105 */
 106void drm_atomic_state_default_release(struct drm_atomic_state *state)
 107{
 108	kfree(state->connectors);
 109	kfree(state->crtcs);
 110	kfree(state->planes);
 111	kfree(state->private_objs);
 112}
 113EXPORT_SYMBOL(drm_atomic_state_default_release);
 114
 115/**
 116 * drm_atomic_state_init - init new atomic state
 117 * @dev: DRM device
 118 * @state: atomic state
 119 *
 120 * Default implementation for filling in a new atomic state.
 121 * This should only be used by drivers which are still subclassing
 122 * &drm_atomic_state and haven't switched to &drm_private_state yet.
 123 */
 124int
 125drm_atomic_state_init(struct drm_device *dev, struct drm_atomic_state *state)
 126{
 127	kref_init(&state->ref);
 128
 129	/* TODO legacy paths should maybe do a better job about
 130	 * setting this appropriately?
 131	 */
 132	state->allow_modeset = true;
 133
 134	state->crtcs = kcalloc(dev->mode_config.num_crtc,
 135			       sizeof(*state->crtcs), GFP_KERNEL);
 136	if (!state->crtcs)
 137		goto fail;
 138	state->planes = kcalloc(dev->mode_config.num_total_plane,
 139				sizeof(*state->planes), GFP_KERNEL);
 140	if (!state->planes)
 141		goto fail;
 142
 143	/*
 144	 * Because drm_atomic_state can be committed asynchronously we need our
 145	 * own reference and cannot rely on the on implied by drm_file in the
 146	 * ioctl call.
 147	 */
 148	drm_dev_get(dev);
 149	state->dev = dev;
 150
 151	drm_dbg_atomic(dev, "Allocated atomic state %p\n", state);
 152
 153	return 0;
 154fail:
 155	drm_atomic_state_default_release(state);
 156	return -ENOMEM;
 157}
 158EXPORT_SYMBOL(drm_atomic_state_init);
 159
 160/**
 161 * drm_atomic_state_alloc - allocate atomic state
 162 * @dev: DRM device
 163 *
 164 * This allocates an empty atomic state to track updates.
 165 */
 166struct drm_atomic_state *
 167drm_atomic_state_alloc(struct drm_device *dev)
 168{
 169	struct drm_mode_config *config = &dev->mode_config;
 170
 171	if (!config->funcs->atomic_state_alloc) {
 172		struct drm_atomic_state *state;
 173
 174		state = kzalloc(sizeof(*state), GFP_KERNEL);
 175		if (!state)
 176			return NULL;
 177		if (drm_atomic_state_init(dev, state) < 0) {
 178			kfree(state);
 179			return NULL;
 180		}
 181		return state;
 182	}
 183
 184	return config->funcs->atomic_state_alloc(dev);
 185}
 186EXPORT_SYMBOL(drm_atomic_state_alloc);
 187
 188/**
 189 * drm_atomic_state_default_clear - clear base atomic state
 190 * @state: atomic state
 191 *
 192 * Default implementation for clearing atomic state.
 193 * This should only be used by drivers which are still subclassing
 194 * &drm_atomic_state and haven't switched to &drm_private_state yet.
 195 */
 196void drm_atomic_state_default_clear(struct drm_atomic_state *state)
 197{
 198	struct drm_device *dev = state->dev;
 199	struct drm_mode_config *config = &dev->mode_config;
 200	int i;
 201
 202	drm_dbg_atomic(dev, "Clearing atomic state %p\n", state);
 203
 204	for (i = 0; i < state->num_connector; i++) {
 205		struct drm_connector *connector = state->connectors[i].ptr;
 206
 207		if (!connector)
 208			continue;
 209
 210		connector->funcs->atomic_destroy_state(connector,
 211						       state->connectors[i].state);
 212		state->connectors[i].ptr = NULL;
 213		state->connectors[i].state = NULL;
 214		state->connectors[i].old_state = NULL;
 215		state->connectors[i].new_state = NULL;
 216		drm_connector_put(connector);
 217	}
 218
 219	for (i = 0; i < config->num_crtc; i++) {
 220		struct drm_crtc *crtc = state->crtcs[i].ptr;
 221
 222		if (!crtc)
 223			continue;
 224
 225		crtc->funcs->atomic_destroy_state(crtc,
 226						  state->crtcs[i].state);
 227
 228		state->crtcs[i].ptr = NULL;
 229		state->crtcs[i].state = NULL;
 230		state->crtcs[i].old_state = NULL;
 231		state->crtcs[i].new_state = NULL;
 232
 233		if (state->crtcs[i].commit) {
 234			drm_crtc_commit_put(state->crtcs[i].commit);
 235			state->crtcs[i].commit = NULL;
 236		}
 237	}
 238
 239	for (i = 0; i < config->num_total_plane; i++) {
 240		struct drm_plane *plane = state->planes[i].ptr;
 241
 242		if (!plane)
 243			continue;
 244
 245		plane->funcs->atomic_destroy_state(plane,
 246						   state->planes[i].state);
 247		state->planes[i].ptr = NULL;
 248		state->planes[i].state = NULL;
 249		state->planes[i].old_state = NULL;
 250		state->planes[i].new_state = NULL;
 251	}
 252
 253	for (i = 0; i < state->num_private_objs; i++) {
 254		struct drm_private_obj *obj = state->private_objs[i].ptr;
 255
 256		obj->funcs->atomic_destroy_state(obj,
 257						 state->private_objs[i].state);
 258		state->private_objs[i].ptr = NULL;
 259		state->private_objs[i].state = NULL;
 260		state->private_objs[i].old_state = NULL;
 261		state->private_objs[i].new_state = NULL;
 262	}
 263	state->num_private_objs = 0;
 264
 265	if (state->fake_commit) {
 266		drm_crtc_commit_put(state->fake_commit);
 267		state->fake_commit = NULL;
 268	}
 269}
 270EXPORT_SYMBOL(drm_atomic_state_default_clear);
 271
 272/**
 273 * drm_atomic_state_clear - clear state object
 274 * @state: atomic state
 275 *
 276 * When the w/w mutex algorithm detects a deadlock we need to back off and drop
 277 * all locks. So someone else could sneak in and change the current modeset
 278 * configuration. Which means that all the state assembled in @state is no
 279 * longer an atomic update to the current state, but to some arbitrary earlier
 280 * state. Which could break assumptions the driver's
 281 * &drm_mode_config_funcs.atomic_check likely relies on.
 282 *
 283 * Hence we must clear all cached state and completely start over, using this
 284 * function.
 285 */
 286void drm_atomic_state_clear(struct drm_atomic_state *state)
 287{
 288	struct drm_device *dev = state->dev;
 289	struct drm_mode_config *config = &dev->mode_config;
 290
 291	if (config->funcs->atomic_state_clear)
 292		config->funcs->atomic_state_clear(state);
 293	else
 294		drm_atomic_state_default_clear(state);
 295}
 296EXPORT_SYMBOL(drm_atomic_state_clear);
 297
 298/**
 299 * __drm_atomic_state_free - free all memory for an atomic state
 300 * @ref: This atomic state to deallocate
 301 *
 302 * This frees all memory associated with an atomic state, including all the
 303 * per-object state for planes, CRTCs and connectors.
 304 */
 305void __drm_atomic_state_free(struct kref *ref)
 306{
 307	struct drm_atomic_state *state = container_of(ref, typeof(*state), ref);
 308	struct drm_device *dev = state->dev;
 309	struct drm_mode_config *config = &dev->mode_config;
 310
 311	drm_atomic_state_clear(state);
 312
 313	drm_dbg_atomic(state->dev, "Freeing atomic state %p\n", state);
 314
 315	if (config->funcs->atomic_state_free) {
 316		config->funcs->atomic_state_free(state);
 317	} else {
 318		drm_atomic_state_default_release(state);
 319		kfree(state);
 320	}
 321
 322	drm_dev_put(dev);
 323}
 324EXPORT_SYMBOL(__drm_atomic_state_free);
 325
 326/**
 327 * drm_atomic_get_crtc_state - get CRTC state
 328 * @state: global atomic state object
 329 * @crtc: CRTC to get state object for
 330 *
 331 * This function returns the CRTC state for the given CRTC, allocating it if
 332 * needed. It will also grab the relevant CRTC lock to make sure that the state
 333 * is consistent.
 334 *
 335 * WARNING: Drivers may only add new CRTC states to a @state if
 336 * drm_atomic_state.allow_modeset is set, or if it's a driver-internal commit
 337 * not created by userspace through an IOCTL call.
 338 *
 339 * Returns:
 340 *
 341 * Either the allocated state or the error code encoded into the pointer. When
 342 * the error is EDEADLK then the w/w mutex code has detected a deadlock and the
 343 * entire atomic sequence must be restarted. All other errors are fatal.
 344 */
 345struct drm_crtc_state *
 346drm_atomic_get_crtc_state(struct drm_atomic_state *state,
 347			  struct drm_crtc *crtc)
 348{
 349	int ret, index = drm_crtc_index(crtc);
 350	struct drm_crtc_state *crtc_state;
 351
 352	WARN_ON(!state->acquire_ctx);
 353
 354	crtc_state = drm_atomic_get_existing_crtc_state(state, crtc);
 355	if (crtc_state)
 356		return crtc_state;
 357
 358	ret = drm_modeset_lock(&crtc->mutex, state->acquire_ctx);
 359	if (ret)
 360		return ERR_PTR(ret);
 361
 362	crtc_state = crtc->funcs->atomic_duplicate_state(crtc);
 363	if (!crtc_state)
 364		return ERR_PTR(-ENOMEM);
 365
 366	state->crtcs[index].state = crtc_state;
 367	state->crtcs[index].old_state = crtc->state;
 368	state->crtcs[index].new_state = crtc_state;
 369	state->crtcs[index].ptr = crtc;
 370	crtc_state->state = state;
 371
 372	drm_dbg_atomic(state->dev, "Added [CRTC:%d:%s] %p state to %p\n",
 373		       crtc->base.id, crtc->name, crtc_state, state);
 374
 375	return crtc_state;
 376}
 377EXPORT_SYMBOL(drm_atomic_get_crtc_state);
 378
 379static int drm_atomic_crtc_check(const struct drm_crtc_state *old_crtc_state,
 380				 const struct drm_crtc_state *new_crtc_state)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 381{
 382	struct drm_crtc *crtc = new_crtc_state->crtc;
 
 
 
 
 383
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 384	/* NOTE: we explicitly don't enforce constraints such as primary
 385	 * layer covering entire screen, since that is something we want
 386	 * to allow (on hw that supports it).  For hw that does not, it
 387	 * should be checked in driver's crtc->atomic_check() vfunc.
 388	 *
 389	 * TODO: Add generic modeset state checks once we support those.
 390	 */
 391
 392	if (new_crtc_state->active && !new_crtc_state->enable) {
 393		drm_dbg_atomic(crtc->dev,
 394			       "[CRTC:%d:%s] active without enabled\n",
 395			       crtc->base.id, crtc->name);
 396		return -EINVAL;
 397	}
 398
 399	/* The state->enable vs. state->mode_blob checks can be WARN_ON,
 400	 * as this is a kernel-internal detail that userspace should never
 401	 * be able to trigger.
 402	 */
 403	if (drm_core_check_feature(crtc->dev, DRIVER_ATOMIC) &&
 404	    WARN_ON(new_crtc_state->enable && !new_crtc_state->mode_blob)) {
 405		drm_dbg_atomic(crtc->dev,
 406			       "[CRTC:%d:%s] enabled without mode blob\n",
 407			       crtc->base.id, crtc->name);
 408		return -EINVAL;
 409	}
 410
 411	if (drm_core_check_feature(crtc->dev, DRIVER_ATOMIC) &&
 412	    WARN_ON(!new_crtc_state->enable && new_crtc_state->mode_blob)) {
 413		drm_dbg_atomic(crtc->dev,
 414			       "[CRTC:%d:%s] disabled with mode blob\n",
 415			       crtc->base.id, crtc->name);
 416		return -EINVAL;
 417	}
 418
 419	/*
 420	 * Reject event generation for when a CRTC is off and stays off.
 421	 * It wouldn't be hard to implement this, but userspace has a track
 422	 * record of happily burning through 100% cpu (or worse, crash) when the
 423	 * display pipe is suspended. To avoid all that fun just reject updates
 424	 * that ask for events since likely that indicates a bug in the
 425	 * compositor's drawing loop. This is consistent with the vblank IOCTL
 426	 * and legacy page_flip IOCTL which also reject service on a disabled
 427	 * pipe.
 428	 */
 429	if (new_crtc_state->event &&
 430	    !new_crtc_state->active && !old_crtc_state->active) {
 431		drm_dbg_atomic(crtc->dev,
 432			       "[CRTC:%d:%s] requesting event but off\n",
 433			       crtc->base.id, crtc->name);
 434		return -EINVAL;
 435	}
 436
 437	return 0;
 438}
 439
 440static void drm_atomic_crtc_print_state(struct drm_printer *p,
 441		const struct drm_crtc_state *state)
 442{
 443	struct drm_crtc *crtc = state->crtc;
 444
 445	drm_printf(p, "crtc[%u]: %s\n", crtc->base.id, crtc->name);
 446	drm_printf(p, "\tenable=%d\n", state->enable);
 447	drm_printf(p, "\tactive=%d\n", state->active);
 448	drm_printf(p, "\tself_refresh_active=%d\n", state->self_refresh_active);
 449	drm_printf(p, "\tplanes_changed=%d\n", state->planes_changed);
 450	drm_printf(p, "\tmode_changed=%d\n", state->mode_changed);
 451	drm_printf(p, "\tactive_changed=%d\n", state->active_changed);
 452	drm_printf(p, "\tconnectors_changed=%d\n", state->connectors_changed);
 453	drm_printf(p, "\tcolor_mgmt_changed=%d\n", state->color_mgmt_changed);
 454	drm_printf(p, "\tplane_mask=%x\n", state->plane_mask);
 455	drm_printf(p, "\tconnector_mask=%x\n", state->connector_mask);
 456	drm_printf(p, "\tencoder_mask=%x\n", state->encoder_mask);
 457	drm_printf(p, "\tmode: " DRM_MODE_FMT "\n", DRM_MODE_ARG(&state->mode));
 458
 459	if (crtc->funcs->atomic_print_state)
 460		crtc->funcs->atomic_print_state(p, state);
 461}
 462
 463static int drm_atomic_connector_check(struct drm_connector *connector,
 464		struct drm_connector_state *state)
 465{
 466	struct drm_crtc_state *crtc_state;
 467	struct drm_writeback_job *writeback_job = state->writeback_job;
 468	const struct drm_display_info *info = &connector->display_info;
 469
 470	state->max_bpc = info->bpc ? info->bpc : 8;
 471	if (connector->max_bpc_property)
 472		state->max_bpc = min(state->max_bpc, state->max_requested_bpc);
 473
 474	if ((connector->connector_type != DRM_MODE_CONNECTOR_WRITEBACK) || !writeback_job)
 475		return 0;
 476
 477	if (writeback_job->fb && !state->crtc) {
 478		drm_dbg_atomic(connector->dev,
 479			       "[CONNECTOR:%d:%s] framebuffer without CRTC\n",
 480			       connector->base.id, connector->name);
 481		return -EINVAL;
 482	}
 483
 484	if (state->crtc)
 485		crtc_state = drm_atomic_get_existing_crtc_state(state->state,
 486								state->crtc);
 487
 488	if (writeback_job->fb && !crtc_state->active) {
 489		drm_dbg_atomic(connector->dev,
 490			       "[CONNECTOR:%d:%s] has framebuffer, but [CRTC:%d] is off\n",
 491			       connector->base.id, connector->name,
 492			       state->crtc->base.id);
 493		return -EINVAL;
 494	}
 495
 496	if (!writeback_job->fb) {
 497		if (writeback_job->out_fence) {
 498			drm_dbg_atomic(connector->dev,
 499				       "[CONNECTOR:%d:%s] requesting out-fence without framebuffer\n",
 500				       connector->base.id, connector->name);
 501			return -EINVAL;
 502		}
 503
 504		drm_writeback_cleanup_job(writeback_job);
 505		state->writeback_job = NULL;
 506	}
 507
 508	return 0;
 509}
 510
 511/**
 512 * drm_atomic_get_plane_state - get plane state
 513 * @state: global atomic state object
 514 * @plane: plane to get state object for
 515 *
 516 * This function returns the plane state for the given plane, allocating it if
 517 * needed. It will also grab the relevant plane lock to make sure that the state
 518 * is consistent.
 519 *
 520 * Returns:
 521 *
 522 * Either the allocated state or the error code encoded into the pointer. When
 523 * the error is EDEADLK then the w/w mutex code has detected a deadlock and the
 524 * entire atomic sequence must be restarted. All other errors are fatal.
 525 */
 526struct drm_plane_state *
 527drm_atomic_get_plane_state(struct drm_atomic_state *state,
 528			  struct drm_plane *plane)
 529{
 530	int ret, index = drm_plane_index(plane);
 531	struct drm_plane_state *plane_state;
 532
 533	WARN_ON(!state->acquire_ctx);
 534
 535	/* the legacy pointers should never be set */
 536	WARN_ON(plane->fb);
 537	WARN_ON(plane->old_fb);
 538	WARN_ON(plane->crtc);
 539
 540	plane_state = drm_atomic_get_existing_plane_state(state, plane);
 541	if (plane_state)
 542		return plane_state;
 543
 544	ret = drm_modeset_lock(&plane->mutex, state->acquire_ctx);
 545	if (ret)
 546		return ERR_PTR(ret);
 547
 548	plane_state = plane->funcs->atomic_duplicate_state(plane);
 549	if (!plane_state)
 550		return ERR_PTR(-ENOMEM);
 551
 552	state->planes[index].state = plane_state;
 553	state->planes[index].ptr = plane;
 554	state->planes[index].old_state = plane->state;
 555	state->planes[index].new_state = plane_state;
 556	plane_state->state = state;
 557
 558	drm_dbg_atomic(plane->dev, "Added [PLANE:%d:%s] %p state to %p\n",
 559		       plane->base.id, plane->name, plane_state, state);
 560
 561	if (plane_state->crtc) {
 562		struct drm_crtc_state *crtc_state;
 563
 564		crtc_state = drm_atomic_get_crtc_state(state,
 565						       plane_state->crtc);
 566		if (IS_ERR(crtc_state))
 567			return ERR_CAST(crtc_state);
 568	}
 569
 570	return plane_state;
 571}
 572EXPORT_SYMBOL(drm_atomic_get_plane_state);
 573
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 574static bool
 575plane_switching_crtc(const struct drm_plane_state *old_plane_state,
 576		     const struct drm_plane_state *new_plane_state)
 
 577{
 578	if (!old_plane_state->crtc || !new_plane_state->crtc)
 579		return false;
 580
 581	if (old_plane_state->crtc == new_plane_state->crtc)
 582		return false;
 583
 584	/* This could be refined, but currently there's no helper or driver code
 585	 * to implement direct switching of active planes nor userspace to take
 586	 * advantage of more direct plane switching without the intermediate
 587	 * full OFF state.
 588	 */
 589	return true;
 590}
 591
 592/**
 593 * drm_atomic_plane_check - check plane state
 594 * @old_plane_state: old plane state to check
 595 * @new_plane_state: new plane state to check
 596 *
 597 * Provides core sanity checks for plane state.
 598 *
 599 * RETURNS:
 600 * Zero on success, error code on failure
 601 */
 602static int drm_atomic_plane_check(const struct drm_plane_state *old_plane_state,
 603				  const struct drm_plane_state *new_plane_state)
 604{
 605	struct drm_plane *plane = new_plane_state->plane;
 606	struct drm_crtc *crtc = new_plane_state->crtc;
 607	const struct drm_framebuffer *fb = new_plane_state->fb;
 608	unsigned int fb_width, fb_height;
 609	struct drm_mode_rect *clips;
 610	uint32_t num_clips;
 611	int ret;
 612
 613	/* either *both* CRTC and FB must be set, or neither */
 614	if (crtc && !fb) {
 615		drm_dbg_atomic(plane->dev, "[PLANE:%d:%s] CRTC set but no FB\n",
 616			       plane->base.id, plane->name);
 617		return -EINVAL;
 618	} else if (fb && !crtc) {
 619		drm_dbg_atomic(plane->dev, "[PLANE:%d:%s] FB set but no CRTC\n",
 620			       plane->base.id, plane->name);
 621		return -EINVAL;
 622	}
 623
 624	/* if disabled, we don't care about the rest of the state: */
 625	if (!crtc)
 626		return 0;
 627
 628	/* Check whether this plane is usable on this CRTC */
 629	if (!(plane->possible_crtcs & drm_crtc_mask(crtc))) {
 630		drm_dbg_atomic(plane->dev,
 631			       "Invalid [CRTC:%d:%s] for [PLANE:%d:%s]\n",
 632			       crtc->base.id, crtc->name,
 633			       plane->base.id, plane->name);
 634		return -EINVAL;
 635	}
 636
 637	/* Check whether this plane supports the fb pixel format. */
 638	ret = drm_plane_check_pixel_format(plane, fb->format->format,
 639					   fb->modifier);
 640	if (ret) {
 641		drm_dbg_atomic(plane->dev,
 642			       "[PLANE:%d:%s] invalid pixel format %p4cc, modifier 0x%llx\n",
 643			       plane->base.id, plane->name,
 644			       &fb->format->format, fb->modifier);
 
 645		return ret;
 646	}
 647
 648	/* Give drivers some help against integer overflows */
 649	if (new_plane_state->crtc_w > INT_MAX ||
 650	    new_plane_state->crtc_x > INT_MAX - (int32_t) new_plane_state->crtc_w ||
 651	    new_plane_state->crtc_h > INT_MAX ||
 652	    new_plane_state->crtc_y > INT_MAX - (int32_t) new_plane_state->crtc_h) {
 653		drm_dbg_atomic(plane->dev,
 654			       "[PLANE:%d:%s] invalid CRTC coordinates %ux%u+%d+%d\n",
 655			       plane->base.id, plane->name,
 656			       new_plane_state->crtc_w, new_plane_state->crtc_h,
 657			       new_plane_state->crtc_x, new_plane_state->crtc_y);
 658		return -ERANGE;
 659	}
 660
 661	fb_width = fb->width << 16;
 662	fb_height = fb->height << 16;
 663
 664	/* Make sure source coordinates are inside the fb. */
 665	if (new_plane_state->src_w > fb_width ||
 666	    new_plane_state->src_x > fb_width - new_plane_state->src_w ||
 667	    new_plane_state->src_h > fb_height ||
 668	    new_plane_state->src_y > fb_height - new_plane_state->src_h) {
 669		drm_dbg_atomic(plane->dev,
 670			       "[PLANE:%d:%s] invalid source coordinates "
 671			       "%u.%06ux%u.%06u+%u.%06u+%u.%06u (fb %ux%u)\n",
 672			       plane->base.id, plane->name,
 673			       new_plane_state->src_w >> 16,
 674			       ((new_plane_state->src_w & 0xffff) * 15625) >> 10,
 675			       new_plane_state->src_h >> 16,
 676			       ((new_plane_state->src_h & 0xffff) * 15625) >> 10,
 677			       new_plane_state->src_x >> 16,
 678			       ((new_plane_state->src_x & 0xffff) * 15625) >> 10,
 679			       new_plane_state->src_y >> 16,
 680			       ((new_plane_state->src_y & 0xffff) * 15625) >> 10,
 681			       fb->width, fb->height);
 682		return -ENOSPC;
 683	}
 684
 685	clips = __drm_plane_get_damage_clips(new_plane_state);
 686	num_clips = drm_plane_get_damage_clips_count(new_plane_state);
 687
 688	/* Make sure damage clips are valid and inside the fb. */
 689	while (num_clips > 0) {
 690		if (clips->x1 >= clips->x2 ||
 691		    clips->y1 >= clips->y2 ||
 692		    clips->x1 < 0 ||
 693		    clips->y1 < 0 ||
 694		    clips->x2 > fb_width ||
 695		    clips->y2 > fb_height) {
 696			drm_dbg_atomic(plane->dev,
 697				       "[PLANE:%d:%s] invalid damage clip %d %d %d %d\n",
 698				       plane->base.id, plane->name, clips->x1,
 699				       clips->y1, clips->x2, clips->y2);
 700			return -EINVAL;
 701		}
 702		clips++;
 703		num_clips--;
 704	}
 705
 706	if (plane_switching_crtc(old_plane_state, new_plane_state)) {
 707		drm_dbg_atomic(plane->dev,
 708			       "[PLANE:%d:%s] switching CRTC directly\n",
 709			       plane->base.id, plane->name);
 710		return -EINVAL;
 711	}
 712
 713	return 0;
 714}
 715
 716static void drm_atomic_plane_print_state(struct drm_printer *p,
 717		const struct drm_plane_state *state)
 718{
 719	struct drm_plane *plane = state->plane;
 720	struct drm_rect src  = drm_plane_state_src(state);
 721	struct drm_rect dest = drm_plane_state_dest(state);
 722
 723	drm_printf(p, "plane[%u]: %s\n", plane->base.id, plane->name);
 724	drm_printf(p, "\tcrtc=%s\n", state->crtc ? state->crtc->name : "(null)");
 725	drm_printf(p, "\tfb=%u\n", state->fb ? state->fb->base.id : 0);
 726	if (state->fb)
 727		drm_framebuffer_print_info(p, 2, state->fb);
 728	drm_printf(p, "\tcrtc-pos=" DRM_RECT_FMT "\n", DRM_RECT_ARG(&dest));
 729	drm_printf(p, "\tsrc-pos=" DRM_RECT_FP_FMT "\n", DRM_RECT_FP_ARG(&src));
 730	drm_printf(p, "\trotation=%x\n", state->rotation);
 731	drm_printf(p, "\tnormalized-zpos=%x\n", state->normalized_zpos);
 732	drm_printf(p, "\tcolor-encoding=%s\n",
 733		   drm_get_color_encoding_name(state->color_encoding));
 734	drm_printf(p, "\tcolor-range=%s\n",
 735		   drm_get_color_range_name(state->color_range));
 736	drm_printf(p, "\tcolor_mgmt_changed=%d\n", state->color_mgmt_changed);
 737
 738	if (plane->funcs->atomic_print_state)
 739		plane->funcs->atomic_print_state(p, state);
 740}
 741
 742/**
 743 * DOC: handling driver private state
 744 *
 745 * Very often the DRM objects exposed to userspace in the atomic modeset api
 746 * (&drm_connector, &drm_crtc and &drm_plane) do not map neatly to the
 747 * underlying hardware. Especially for any kind of shared resources (e.g. shared
 748 * clocks, scaler units, bandwidth and fifo limits shared among a group of
 749 * planes or CRTCs, and so on) it makes sense to model these as independent
 750 * objects. Drivers then need to do similar state tracking and commit ordering for
 751 * such private (since not exposed to userspace) objects as the atomic core and
 752 * helpers already provide for connectors, planes and CRTCs.
 753 *
 754 * To make this easier on drivers the atomic core provides some support to track
 755 * driver private state objects using struct &drm_private_obj, with the
 756 * associated state struct &drm_private_state.
 757 *
 758 * Similar to userspace-exposed objects, private state structures can be
 759 * acquired by calling drm_atomic_get_private_obj_state(). This also takes care
 760 * of locking, hence drivers should not have a need to call drm_modeset_lock()
 761 * directly. Sequence of the actual hardware state commit is not handled,
 762 * drivers might need to keep track of struct drm_crtc_commit within subclassed
 763 * structure of &drm_private_state as necessary, e.g. similar to
 764 * &drm_plane_state.commit. See also &drm_atomic_state.fake_commit.
 765 *
 766 * All private state structures contained in a &drm_atomic_state update can be
 767 * iterated using for_each_oldnew_private_obj_in_state(),
 768 * for_each_new_private_obj_in_state() and for_each_old_private_obj_in_state().
 769 * Drivers are recommended to wrap these for each type of driver private state
 770 * object they have, filtering on &drm_private_obj.funcs using for_each_if(), at
 771 * least if they want to iterate over all objects of a given type.
 772 *
 773 * An earlier way to handle driver private state was by subclassing struct
 774 * &drm_atomic_state. But since that encourages non-standard ways to implement
 775 * the check/commit split atomic requires (by using e.g. "check and rollback or
 776 * commit instead" of "duplicate state, check, then either commit or release
 777 * duplicated state) it is deprecated in favour of using &drm_private_state.
 778 */
 779
 780/**
 781 * drm_atomic_private_obj_init - initialize private object
 782 * @dev: DRM device this object will be attached to
 783 * @obj: private object
 784 * @state: initial private object state
 785 * @funcs: pointer to the struct of function pointers that identify the object
 786 * type
 787 *
 788 * Initialize the private object, which can be embedded into any
 789 * driver private object that needs its own atomic state.
 790 */
 791void
 792drm_atomic_private_obj_init(struct drm_device *dev,
 793			    struct drm_private_obj *obj,
 794			    struct drm_private_state *state,
 795			    const struct drm_private_state_funcs *funcs)
 796{
 797	memset(obj, 0, sizeof(*obj));
 798
 799	drm_modeset_lock_init(&obj->lock);
 800
 801	obj->state = state;
 802	obj->funcs = funcs;
 803	list_add_tail(&obj->head, &dev->mode_config.privobj_list);
 804
 805	state->obj = obj;
 806}
 807EXPORT_SYMBOL(drm_atomic_private_obj_init);
 808
 809/**
 810 * drm_atomic_private_obj_fini - finalize private object
 811 * @obj: private object
 812 *
 813 * Finalize the private object.
 814 */
 815void
 816drm_atomic_private_obj_fini(struct drm_private_obj *obj)
 817{
 818	list_del(&obj->head);
 819	obj->funcs->atomic_destroy_state(obj, obj->state);
 820	drm_modeset_lock_fini(&obj->lock);
 821}
 822EXPORT_SYMBOL(drm_atomic_private_obj_fini);
 823
 824/**
 825 * drm_atomic_get_private_obj_state - get private object state
 826 * @state: global atomic state
 827 * @obj: private object to get the state for
 828 *
 829 * This function returns the private object state for the given private object,
 830 * allocating the state if needed. It will also grab the relevant private
 831 * object lock to make sure that the state is consistent.
 832 *
 833 * RETURNS:
 834 *
 835 * Either the allocated state or the error code encoded into a pointer.
 836 */
 837struct drm_private_state *
 838drm_atomic_get_private_obj_state(struct drm_atomic_state *state,
 839				 struct drm_private_obj *obj)
 840{
 841	int index, num_objs, i, ret;
 842	size_t size;
 843	struct __drm_private_objs_state *arr;
 844	struct drm_private_state *obj_state;
 845
 846	for (i = 0; i < state->num_private_objs; i++)
 847		if (obj == state->private_objs[i].ptr)
 848			return state->private_objs[i].state;
 849
 850	ret = drm_modeset_lock(&obj->lock, state->acquire_ctx);
 851	if (ret)
 852		return ERR_PTR(ret);
 853
 854	num_objs = state->num_private_objs + 1;
 855	size = sizeof(*state->private_objs) * num_objs;
 856	arr = krealloc(state->private_objs, size, GFP_KERNEL);
 857	if (!arr)
 858		return ERR_PTR(-ENOMEM);
 859
 860	state->private_objs = arr;
 861	index = state->num_private_objs;
 862	memset(&state->private_objs[index], 0, sizeof(*state->private_objs));
 863
 864	obj_state = obj->funcs->atomic_duplicate_state(obj);
 865	if (!obj_state)
 866		return ERR_PTR(-ENOMEM);
 867
 868	state->private_objs[index].state = obj_state;
 869	state->private_objs[index].old_state = obj->state;
 870	state->private_objs[index].new_state = obj_state;
 871	state->private_objs[index].ptr = obj;
 872	obj_state->state = state;
 873
 874	state->num_private_objs = num_objs;
 875
 876	drm_dbg_atomic(state->dev,
 877		       "Added new private object %p state %p to %p\n",
 878		       obj, obj_state, state);
 879
 880	return obj_state;
 881}
 882EXPORT_SYMBOL(drm_atomic_get_private_obj_state);
 883
 884/**
 885 * drm_atomic_get_old_private_obj_state
 886 * @state: global atomic state object
 887 * @obj: private_obj to grab
 888 *
 889 * This function returns the old private object state for the given private_obj,
 890 * or NULL if the private_obj is not part of the global atomic state.
 891 */
 892struct drm_private_state *
 893drm_atomic_get_old_private_obj_state(const struct drm_atomic_state *state,
 894				     struct drm_private_obj *obj)
 895{
 896	int i;
 897
 898	for (i = 0; i < state->num_private_objs; i++)
 899		if (obj == state->private_objs[i].ptr)
 900			return state->private_objs[i].old_state;
 901
 902	return NULL;
 903}
 904EXPORT_SYMBOL(drm_atomic_get_old_private_obj_state);
 905
 906/**
 907 * drm_atomic_get_new_private_obj_state
 908 * @state: global atomic state object
 909 * @obj: private_obj to grab
 910 *
 911 * This function returns the new private object state for the given private_obj,
 912 * or NULL if the private_obj is not part of the global atomic state.
 913 */
 914struct drm_private_state *
 915drm_atomic_get_new_private_obj_state(const struct drm_atomic_state *state,
 916				     struct drm_private_obj *obj)
 917{
 918	int i;
 919
 920	for (i = 0; i < state->num_private_objs; i++)
 921		if (obj == state->private_objs[i].ptr)
 922			return state->private_objs[i].new_state;
 923
 924	return NULL;
 925}
 926EXPORT_SYMBOL(drm_atomic_get_new_private_obj_state);
 927
 928/**
 929 * drm_atomic_get_old_connector_for_encoder - Get old connector for an encoder
 930 * @state: Atomic state
 931 * @encoder: The encoder to fetch the connector state for
 932 *
 933 * This function finds and returns the connector that was connected to @encoder
 934 * as specified by the @state.
 935 *
 936 * If there is no connector in @state which previously had @encoder connected to
 937 * it, this function will return NULL. While this may seem like an invalid use
 938 * case, it is sometimes useful to differentiate commits which had no prior
 939 * connectors attached to @encoder vs ones that did (and to inspect their
 940 * state). This is especially true in enable hooks because the pipeline has
 941 * changed.
 942 *
 943 * Returns: The old connector connected to @encoder, or NULL if the encoder is
 944 * not connected.
 945 */
 946struct drm_connector *
 947drm_atomic_get_old_connector_for_encoder(const struct drm_atomic_state *state,
 948					 struct drm_encoder *encoder)
 949{
 950	struct drm_connector_state *conn_state;
 951	struct drm_connector *connector;
 952	unsigned int i;
 953
 954	for_each_old_connector_in_state(state, connector, conn_state, i) {
 955		if (conn_state->best_encoder == encoder)
 956			return connector;
 957	}
 958
 959	return NULL;
 960}
 961EXPORT_SYMBOL(drm_atomic_get_old_connector_for_encoder);
 962
 963/**
 964 * drm_atomic_get_new_connector_for_encoder - Get new connector for an encoder
 965 * @state: Atomic state
 966 * @encoder: The encoder to fetch the connector state for
 967 *
 968 * This function finds and returns the connector that will be connected to
 969 * @encoder as specified by the @state.
 970 *
 971 * If there is no connector in @state which will have @encoder connected to it,
 972 * this function will return NULL. While this may seem like an invalid use case,
 973 * it is sometimes useful to differentiate commits which have no connectors
 974 * attached to @encoder vs ones that do (and to inspect their state). This is
 975 * especially true in disable hooks because the pipeline will change.
 976 *
 977 * Returns: The new connector connected to @encoder, or NULL if the encoder is
 978 * not connected.
 979 */
 980struct drm_connector *
 981drm_atomic_get_new_connector_for_encoder(const struct drm_atomic_state *state,
 982					 struct drm_encoder *encoder)
 983{
 984	struct drm_connector_state *conn_state;
 985	struct drm_connector *connector;
 986	unsigned int i;
 987
 988	for_each_new_connector_in_state(state, connector, conn_state, i) {
 989		if (conn_state->best_encoder == encoder)
 990			return connector;
 991	}
 992
 993	return NULL;
 994}
 995EXPORT_SYMBOL(drm_atomic_get_new_connector_for_encoder);
 996
 997/**
 998 * drm_atomic_get_old_crtc_for_encoder - Get old crtc for an encoder
 999 * @state: Atomic state
1000 * @encoder: The encoder to fetch the crtc state for
1001 *
1002 * This function finds and returns the crtc that was connected to @encoder
1003 * as specified by the @state.
1004 *
1005 * Returns: The old crtc connected to @encoder, or NULL if the encoder is
1006 * not connected.
1007 */
1008struct drm_crtc *
1009drm_atomic_get_old_crtc_for_encoder(struct drm_atomic_state *state,
1010				    struct drm_encoder *encoder)
1011{
1012	struct drm_connector *connector;
1013	struct drm_connector_state *conn_state;
1014
1015	connector = drm_atomic_get_old_connector_for_encoder(state, encoder);
1016	if (!connector)
1017		return NULL;
1018
1019	conn_state = drm_atomic_get_old_connector_state(state, connector);
1020	if (!conn_state)
1021		return NULL;
1022
1023	return conn_state->crtc;
1024}
1025EXPORT_SYMBOL(drm_atomic_get_old_crtc_for_encoder);
1026
1027/**
1028 * drm_atomic_get_new_crtc_for_encoder - Get new crtc for an encoder
1029 * @state: Atomic state
1030 * @encoder: The encoder to fetch the crtc state for
1031 *
1032 * This function finds and returns the crtc that will be connected to @encoder
1033 * as specified by the @state.
1034 *
1035 * Returns: The new crtc connected to @encoder, or NULL if the encoder is
1036 * not connected.
1037 */
1038struct drm_crtc *
1039drm_atomic_get_new_crtc_for_encoder(struct drm_atomic_state *state,
1040				    struct drm_encoder *encoder)
1041{
1042	struct drm_connector *connector;
1043	struct drm_connector_state *conn_state;
1044
1045	connector = drm_atomic_get_new_connector_for_encoder(state, encoder);
1046	if (!connector)
1047		return NULL;
1048
1049	conn_state = drm_atomic_get_new_connector_state(state, connector);
1050	if (!conn_state)
1051		return NULL;
1052
1053	return conn_state->crtc;
1054}
1055EXPORT_SYMBOL(drm_atomic_get_new_crtc_for_encoder);
1056
1057/**
1058 * drm_atomic_get_connector_state - get connector state
1059 * @state: global atomic state object
1060 * @connector: connector to get state object for
1061 *
1062 * This function returns the connector state for the given connector,
1063 * allocating it if needed. It will also grab the relevant connector lock to
1064 * make sure that the state is consistent.
1065 *
1066 * Returns:
1067 *
1068 * Either the allocated state or the error code encoded into the pointer. When
1069 * the error is EDEADLK then the w/w mutex code has detected a deadlock and the
1070 * entire atomic sequence must be restarted. All other errors are fatal.
1071 */
1072struct drm_connector_state *
1073drm_atomic_get_connector_state(struct drm_atomic_state *state,
1074			  struct drm_connector *connector)
1075{
1076	int ret, index;
1077	struct drm_mode_config *config = &connector->dev->mode_config;
1078	struct drm_connector_state *connector_state;
1079
1080	WARN_ON(!state->acquire_ctx);
1081
1082	ret = drm_modeset_lock(&config->connection_mutex, state->acquire_ctx);
1083	if (ret)
1084		return ERR_PTR(ret);
1085
1086	index = drm_connector_index(connector);
1087
1088	if (index >= state->num_connector) {
1089		struct __drm_connnectors_state *c;
1090		int alloc = max(index + 1, config->num_connector);
1091
1092		c = krealloc_array(state->connectors, alloc,
1093				   sizeof(*state->connectors), GFP_KERNEL);
1094		if (!c)
1095			return ERR_PTR(-ENOMEM);
1096
1097		state->connectors = c;
1098		memset(&state->connectors[state->num_connector], 0,
1099		       sizeof(*state->connectors) * (alloc - state->num_connector));
1100
1101		state->num_connector = alloc;
1102	}
1103
1104	if (state->connectors[index].state)
1105		return state->connectors[index].state;
1106
1107	connector_state = connector->funcs->atomic_duplicate_state(connector);
1108	if (!connector_state)
1109		return ERR_PTR(-ENOMEM);
1110
1111	drm_connector_get(connector);
1112	state->connectors[index].state = connector_state;
1113	state->connectors[index].old_state = connector->state;
1114	state->connectors[index].new_state = connector_state;
1115	state->connectors[index].ptr = connector;
1116	connector_state->state = state;
1117
1118	drm_dbg_atomic(connector->dev, "Added [CONNECTOR:%d:%s] %p state to %p\n",
1119			 connector->base.id, connector->name,
1120			 connector_state, state);
1121
1122	if (connector_state->crtc) {
1123		struct drm_crtc_state *crtc_state;
1124
1125		crtc_state = drm_atomic_get_crtc_state(state,
1126						       connector_state->crtc);
1127		if (IS_ERR(crtc_state))
1128			return ERR_CAST(crtc_state);
1129	}
1130
1131	return connector_state;
1132}
1133EXPORT_SYMBOL(drm_atomic_get_connector_state);
1134
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1135static void drm_atomic_connector_print_state(struct drm_printer *p,
1136		const struct drm_connector_state *state)
1137{
1138	struct drm_connector *connector = state->connector;
1139
1140	drm_printf(p, "connector[%u]: %s\n", connector->base.id, connector->name);
1141	drm_printf(p, "\tcrtc=%s\n", state->crtc ? state->crtc->name : "(null)");
1142	drm_printf(p, "\tself_refresh_aware=%d\n", state->self_refresh_aware);
1143	drm_printf(p, "\tmax_requested_bpc=%d\n", state->max_requested_bpc);
1144	drm_printf(p, "\tcolorspace=%s\n", drm_get_colorspace_name(state->colorspace));
1145
1146	if (connector->connector_type == DRM_MODE_CONNECTOR_WRITEBACK)
1147		if (state->writeback_job && state->writeback_job->fb)
1148			drm_printf(p, "\tfb=%d\n", state->writeback_job->fb->base.id);
1149
1150	if (connector->funcs->atomic_print_state)
1151		connector->funcs->atomic_print_state(p, state);
1152}
1153
1154/**
1155 * drm_atomic_get_bridge_state - get bridge state
1156 * @state: global atomic state object
1157 * @bridge: bridge to get state object for
1158 *
1159 * This function returns the bridge state for the given bridge, allocating it
1160 * if needed. It will also grab the relevant bridge lock to make sure that the
1161 * state is consistent.
 
 
 
1162 *
1163 * Returns:
1164 *
1165 * Either the allocated state or the error code encoded into the pointer. When
1166 * the error is EDEADLK then the w/w mutex code has detected a deadlock and the
1167 * entire atomic sequence must be restarted.
1168 */
1169struct drm_bridge_state *
1170drm_atomic_get_bridge_state(struct drm_atomic_state *state,
1171			    struct drm_bridge *bridge)
 
1172{
1173	struct drm_private_state *obj_state;
 
1174
1175	obj_state = drm_atomic_get_private_obj_state(state, &bridge->base);
1176	if (IS_ERR(obj_state))
1177		return ERR_CAST(obj_state);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1178
1179	return drm_priv_to_bridge_state(obj_state);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1180}
1181EXPORT_SYMBOL(drm_atomic_get_bridge_state);
1182
1183/**
1184 * drm_atomic_get_old_bridge_state - get old bridge state, if it exists
1185 * @state: global atomic state object
1186 * @bridge: bridge to grab
 
 
 
 
1187 *
1188 * This function returns the old bridge state for the given bridge, or NULL if
1189 * the bridge is not part of the global atomic state.
 
 
1190 */
1191struct drm_bridge_state *
1192drm_atomic_get_old_bridge_state(const struct drm_atomic_state *state,
1193				struct drm_bridge *bridge)
1194{
1195	struct drm_private_state *obj_state;
 
1196
1197	obj_state = drm_atomic_get_old_private_obj_state(state, &bridge->base);
1198	if (!obj_state)
1199		return NULL;
 
 
 
 
 
1200
1201	return drm_priv_to_bridge_state(obj_state);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1202}
1203EXPORT_SYMBOL(drm_atomic_get_old_bridge_state);
1204
1205/**
1206 * drm_atomic_get_new_bridge_state - get new bridge state, if it exists
1207 * @state: global atomic state object
1208 * @bridge: bridge to grab
1209 *
1210 * This function returns the new bridge state for the given bridge, or NULL if
1211 * the bridge is not part of the global atomic state.
 
 
1212 */
1213struct drm_bridge_state *
1214drm_atomic_get_new_bridge_state(const struct drm_atomic_state *state,
1215				struct drm_bridge *bridge)
1216{
1217	struct drm_private_state *obj_state;
 
 
 
 
 
1218
1219	obj_state = drm_atomic_get_new_private_obj_state(state, &bridge->base);
1220	if (!obj_state)
1221		return NULL;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1222
1223	return drm_priv_to_bridge_state(obj_state);
1224}
1225EXPORT_SYMBOL(drm_atomic_get_new_bridge_state);
1226
1227/**
1228 * drm_atomic_add_encoder_bridges - add bridges attached to an encoder
1229 * @state: atomic state
1230 * @encoder: DRM encoder
1231 *
1232 * This function adds all bridges attached to @encoder. This is needed to add
1233 * bridge states to @state and make them available when
1234 * &drm_bridge_funcs.atomic_check(), &drm_bridge_funcs.atomic_pre_enable(),
1235 * &drm_bridge_funcs.atomic_enable(),
1236 * &drm_bridge_funcs.atomic_disable_post_disable() are called.
1237 *
1238 * Returns:
1239 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
1240 * then the w/w mutex code has detected a deadlock and the entire atomic
1241 * sequence must be restarted. All other errors are fatal.
1242 */
1243int
1244drm_atomic_add_encoder_bridges(struct drm_atomic_state *state,
1245			       struct drm_encoder *encoder)
1246{
1247	struct drm_bridge_state *bridge_state;
1248	struct drm_bridge *bridge;
1249
1250	if (!encoder)
1251		return 0;
1252
1253	drm_dbg_atomic(encoder->dev,
1254		       "Adding all bridges for [encoder:%d:%s] to %p\n",
1255		       encoder->base.id, encoder->name, state);
1256
1257	drm_for_each_bridge_in_chain(encoder, bridge) {
1258		/* Skip bridges that don't implement the atomic state hooks. */
1259		if (!bridge->funcs->atomic_duplicate_state)
1260			continue;
1261
1262		bridge_state = drm_atomic_get_bridge_state(state, bridge);
1263		if (IS_ERR(bridge_state))
1264			return PTR_ERR(bridge_state);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1265	}
1266
1267	return 0;
1268}
1269EXPORT_SYMBOL(drm_atomic_add_encoder_bridges);
1270
1271/**
1272 * drm_atomic_add_affected_connectors - add connectors for CRTC
1273 * @state: atomic state
1274 * @crtc: DRM CRTC
1275 *
1276 * This function walks the current configuration and adds all connectors
1277 * currently using @crtc to the atomic configuration @state. Note that this
1278 * function must acquire the connection mutex. This can potentially cause
1279 * unneeded serialization if the update is just for the planes on one CRTC. Hence
1280 * drivers and helpers should only call this when really needed (e.g. when a
1281 * full modeset needs to happen due to some change).
1282 *
1283 * Returns:
1284 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
1285 * then the w/w mutex code has detected a deadlock and the entire atomic
1286 * sequence must be restarted. All other errors are fatal.
1287 */
1288int
1289drm_atomic_add_affected_connectors(struct drm_atomic_state *state,
1290				   struct drm_crtc *crtc)
1291{
1292	struct drm_mode_config *config = &state->dev->mode_config;
1293	struct drm_connector *connector;
1294	struct drm_connector_state *conn_state;
1295	struct drm_connector_list_iter conn_iter;
1296	struct drm_crtc_state *crtc_state;
1297	int ret;
1298
1299	crtc_state = drm_atomic_get_crtc_state(state, crtc);
1300	if (IS_ERR(crtc_state))
1301		return PTR_ERR(crtc_state);
1302
1303	ret = drm_modeset_lock(&config->connection_mutex, state->acquire_ctx);
1304	if (ret)
1305		return ret;
1306
1307	drm_dbg_atomic(crtc->dev,
1308		       "Adding all current connectors for [CRTC:%d:%s] to %p\n",
1309		       crtc->base.id, crtc->name, state);
1310
1311	/*
1312	 * Changed connectors are already in @state, so only need to look
1313	 * at the connector_mask in crtc_state.
1314	 */
1315	drm_connector_list_iter_begin(state->dev, &conn_iter);
1316	drm_for_each_connector_iter(connector, &conn_iter) {
1317		if (!(crtc_state->connector_mask & drm_connector_mask(connector)))
1318			continue;
1319
1320		conn_state = drm_atomic_get_connector_state(state, connector);
1321		if (IS_ERR(conn_state)) {
1322			drm_connector_list_iter_end(&conn_iter);
1323			return PTR_ERR(conn_state);
1324		}
1325	}
1326	drm_connector_list_iter_end(&conn_iter);
1327
1328	return 0;
1329}
1330EXPORT_SYMBOL(drm_atomic_add_affected_connectors);
1331
1332/**
1333 * drm_atomic_add_affected_planes - add planes for CRTC
1334 * @state: atomic state
1335 * @crtc: DRM CRTC
1336 *
1337 * This function walks the current configuration and adds all planes
1338 * currently used by @crtc to the atomic configuration @state. This is useful
1339 * when an atomic commit also needs to check all currently enabled plane on
1340 * @crtc, e.g. when changing the mode. It's also useful when re-enabling a CRTC
1341 * to avoid special code to force-enable all planes.
1342 *
1343 * Since acquiring a plane state will always also acquire the w/w mutex of the
1344 * current CRTC for that plane (if there is any) adding all the plane states for
1345 * a CRTC will not reduce parallelism of atomic updates.
1346 *
1347 * Returns:
1348 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
1349 * then the w/w mutex code has detected a deadlock and the entire atomic
1350 * sequence must be restarted. All other errors are fatal.
1351 */
1352int
1353drm_atomic_add_affected_planes(struct drm_atomic_state *state,
1354			       struct drm_crtc *crtc)
1355{
1356	const struct drm_crtc_state *old_crtc_state =
1357		drm_atomic_get_old_crtc_state(state, crtc);
1358	struct drm_plane *plane;
1359
1360	WARN_ON(!drm_atomic_get_new_crtc_state(state, crtc));
1361
1362	drm_dbg_atomic(crtc->dev,
1363		       "Adding all current planes for [CRTC:%d:%s] to %p\n",
1364		       crtc->base.id, crtc->name, state);
1365
1366	drm_for_each_plane_mask(plane, state->dev, old_crtc_state->plane_mask) {
1367		struct drm_plane_state *plane_state =
1368			drm_atomic_get_plane_state(state, plane);
1369
1370		if (IS_ERR(plane_state))
1371			return PTR_ERR(plane_state);
1372	}
1373	return 0;
1374}
1375EXPORT_SYMBOL(drm_atomic_add_affected_planes);
1376
1377/**
1378 * drm_atomic_check_only - check whether a given config would work
1379 * @state: atomic configuration to check
1380 *
1381 * Note that this function can return -EDEADLK if the driver needed to acquire
1382 * more locks but encountered a deadlock. The caller must then do the usual w/w
1383 * backoff dance and restart. All other errors are fatal.
1384 *
1385 * Returns:
1386 * 0 on success, negative error code on failure.
1387 */
1388int drm_atomic_check_only(struct drm_atomic_state *state)
1389{
1390	struct drm_device *dev = state->dev;
1391	struct drm_mode_config *config = &dev->mode_config;
1392	struct drm_plane *plane;
1393	struct drm_plane_state *old_plane_state;
1394	struct drm_plane_state *new_plane_state;
1395	struct drm_crtc *crtc;
1396	struct drm_crtc_state *old_crtc_state;
1397	struct drm_crtc_state *new_crtc_state;
1398	struct drm_connector *conn;
1399	struct drm_connector_state *conn_state;
1400	unsigned int requested_crtc = 0;
1401	unsigned int affected_crtc = 0;
1402	int i, ret = 0;
1403
1404	drm_dbg_atomic(dev, "checking %p\n", state);
1405
1406	for_each_new_crtc_in_state(state, crtc, new_crtc_state, i) {
1407		if (new_crtc_state->enable)
1408			requested_crtc |= drm_crtc_mask(crtc);
1409	}
1410
1411	for_each_oldnew_plane_in_state(state, plane, old_plane_state, new_plane_state, i) {
1412		ret = drm_atomic_plane_check(old_plane_state, new_plane_state);
1413		if (ret) {
1414			drm_dbg_atomic(dev, "[PLANE:%d:%s] atomic core check failed\n",
1415				       plane->base.id, plane->name);
1416			return ret;
1417		}
1418	}
1419
1420	for_each_oldnew_crtc_in_state(state, crtc, old_crtc_state, new_crtc_state, i) {
1421		ret = drm_atomic_crtc_check(old_crtc_state, new_crtc_state);
1422		if (ret) {
1423			drm_dbg_atomic(dev, "[CRTC:%d:%s] atomic core check failed\n",
1424				       crtc->base.id, crtc->name);
1425			return ret;
1426		}
1427	}
1428
1429	for_each_new_connector_in_state(state, conn, conn_state, i) {
1430		ret = drm_atomic_connector_check(conn, conn_state);
1431		if (ret) {
1432			drm_dbg_atomic(dev, "[CONNECTOR:%d:%s] atomic core check failed\n",
1433				       conn->base.id, conn->name);
1434			return ret;
1435		}
1436	}
1437
1438	if (config->funcs->atomic_check) {
1439		ret = config->funcs->atomic_check(state->dev, state);
1440
1441		if (ret) {
1442			drm_dbg_atomic(dev, "atomic driver check for %p failed: %d\n",
1443				       state, ret);
1444			return ret;
1445		}
1446	}
1447
1448	if (!state->allow_modeset) {
1449		for_each_new_crtc_in_state(state, crtc, new_crtc_state, i) {
1450			if (drm_atomic_crtc_needs_modeset(new_crtc_state)) {
1451				drm_dbg_atomic(dev, "[CRTC:%d:%s] requires full modeset\n",
1452					       crtc->base.id, crtc->name);
1453				return -EINVAL;
1454			}
1455		}
1456	}
1457
1458	for_each_new_crtc_in_state(state, crtc, new_crtc_state, i) {
1459		if (new_crtc_state->enable)
1460			affected_crtc |= drm_crtc_mask(crtc);
1461	}
1462
1463	/*
1464	 * For commits that allow modesets drivers can add other CRTCs to the
1465	 * atomic commit, e.g. when they need to reallocate global resources.
1466	 * This can cause spurious EBUSY, which robs compositors of a very
1467	 * effective sanity check for their drawing loop. Therefor only allow
1468	 * drivers to add unrelated CRTC states for modeset commits.
1469	 *
1470	 * FIXME: Should add affected_crtc mask to the ATOMIC IOCTL as an output
1471	 * so compositors know what's going on.
1472	 */
1473	if (affected_crtc != requested_crtc) {
1474		drm_dbg_atomic(dev,
1475			       "driver added CRTC to commit: requested 0x%x, affected 0x%0x\n",
1476			       requested_crtc, affected_crtc);
1477		WARN(!state->allow_modeset, "adding CRTC not allowed without modesets: requested 0x%x, affected 0x%0x\n",
1478		     requested_crtc, affected_crtc);
1479	}
1480
1481	return 0;
1482}
1483EXPORT_SYMBOL(drm_atomic_check_only);
1484
1485/**
1486 * drm_atomic_commit - commit configuration atomically
1487 * @state: atomic configuration to check
1488 *
1489 * Note that this function can return -EDEADLK if the driver needed to acquire
1490 * more locks but encountered a deadlock. The caller must then do the usual w/w
1491 * backoff dance and restart. All other errors are fatal.
1492 *
1493 * This function will take its own reference on @state.
1494 * Callers should always release their reference with drm_atomic_state_put().
1495 *
1496 * Returns:
1497 * 0 on success, negative error code on failure.
1498 */
1499int drm_atomic_commit(struct drm_atomic_state *state)
1500{
1501	struct drm_mode_config *config = &state->dev->mode_config;
1502	struct drm_printer p = drm_info_printer(state->dev->dev);
1503	int ret;
1504
1505	if (drm_debug_enabled(DRM_UT_STATE))
1506		drm_atomic_print_new_state(state, &p);
1507
1508	ret = drm_atomic_check_only(state);
1509	if (ret)
1510		return ret;
1511
1512	drm_dbg_atomic(state->dev, "committing %p\n", state);
1513
1514	return config->funcs->atomic_commit(state->dev, state, false);
1515}
1516EXPORT_SYMBOL(drm_atomic_commit);
1517
1518/**
1519 * drm_atomic_nonblocking_commit - atomic nonblocking commit
1520 * @state: atomic configuration to check
1521 *
1522 * Note that this function can return -EDEADLK if the driver needed to acquire
1523 * more locks but encountered a deadlock. The caller must then do the usual w/w
1524 * backoff dance and restart. All other errors are fatal.
1525 *
1526 * This function will take its own reference on @state.
1527 * Callers should always release their reference with drm_atomic_state_put().
1528 *
1529 * Returns:
1530 * 0 on success, negative error code on failure.
1531 */
1532int drm_atomic_nonblocking_commit(struct drm_atomic_state *state)
1533{
1534	struct drm_mode_config *config = &state->dev->mode_config;
1535	int ret;
1536
1537	ret = drm_atomic_check_only(state);
1538	if (ret)
1539		return ret;
1540
1541	drm_dbg_atomic(state->dev, "committing %p nonblocking\n", state);
1542
1543	return config->funcs->atomic_commit(state->dev, state, true);
1544}
1545EXPORT_SYMBOL(drm_atomic_nonblocking_commit);
1546
1547/* just used from drm-client and atomic-helper: */
1548int __drm_atomic_helper_disable_plane(struct drm_plane *plane,
1549				      struct drm_plane_state *plane_state)
1550{
1551	int ret;
1552
1553	ret = drm_atomic_set_crtc_for_plane(plane_state, NULL);
1554	if (ret != 0)
1555		return ret;
1556
1557	drm_atomic_set_fb_for_plane(plane_state, NULL);
1558	plane_state->crtc_x = 0;
1559	plane_state->crtc_y = 0;
1560	plane_state->crtc_w = 0;
1561	plane_state->crtc_h = 0;
1562	plane_state->src_x = 0;
1563	plane_state->src_y = 0;
1564	plane_state->src_w = 0;
1565	plane_state->src_h = 0;
1566
1567	return 0;
1568}
1569EXPORT_SYMBOL(__drm_atomic_helper_disable_plane);
1570
1571static int update_output_state(struct drm_atomic_state *state,
1572			       struct drm_mode_set *set)
1573{
1574	struct drm_device *dev = set->crtc->dev;
1575	struct drm_crtc *crtc;
1576	struct drm_crtc_state *new_crtc_state;
1577	struct drm_connector *connector;
1578	struct drm_connector_state *new_conn_state;
1579	int ret, i;
1580
1581	ret = drm_modeset_lock(&dev->mode_config.connection_mutex,
1582			       state->acquire_ctx);
1583	if (ret)
1584		return ret;
1585
1586	/* First disable all connectors on the target crtc. */
1587	ret = drm_atomic_add_affected_connectors(state, set->crtc);
1588	if (ret)
1589		return ret;
1590
1591	for_each_new_connector_in_state(state, connector, new_conn_state, i) {
1592		if (new_conn_state->crtc == set->crtc) {
1593			ret = drm_atomic_set_crtc_for_connector(new_conn_state,
1594								NULL);
1595			if (ret)
1596				return ret;
1597
1598			/* Make sure legacy setCrtc always re-trains */
1599			new_conn_state->link_status = DRM_LINK_STATUS_GOOD;
1600		}
1601	}
1602
1603	/* Then set all connectors from set->connectors on the target crtc */
1604	for (i = 0; i < set->num_connectors; i++) {
1605		new_conn_state = drm_atomic_get_connector_state(state,
1606								set->connectors[i]);
1607		if (IS_ERR(new_conn_state))
1608			return PTR_ERR(new_conn_state);
1609
1610		ret = drm_atomic_set_crtc_for_connector(new_conn_state,
1611							set->crtc);
1612		if (ret)
1613			return ret;
1614	}
1615
1616	for_each_new_crtc_in_state(state, crtc, new_crtc_state, i) {
1617		/*
1618		 * Don't update ->enable for the CRTC in the set_config request,
1619		 * since a mismatch would indicate a bug in the upper layers.
1620		 * The actual modeset code later on will catch any
1621		 * inconsistencies here.
1622		 */
1623		if (crtc == set->crtc)
1624			continue;
1625
1626		if (!new_crtc_state->connector_mask) {
1627			ret = drm_atomic_set_mode_prop_for_crtc(new_crtc_state,
1628								NULL);
1629			if (ret < 0)
1630				return ret;
1631
1632			new_crtc_state->active = false;
1633		}
1634	}
1635
1636	return 0;
1637}
1638
1639/* just used from drm-client and atomic-helper: */
1640int __drm_atomic_helper_set_config(struct drm_mode_set *set,
1641				   struct drm_atomic_state *state)
1642{
1643	struct drm_crtc_state *crtc_state;
1644	struct drm_plane_state *primary_state;
1645	struct drm_crtc *crtc = set->crtc;
1646	int hdisplay, vdisplay;
1647	int ret;
1648
1649	crtc_state = drm_atomic_get_crtc_state(state, crtc);
1650	if (IS_ERR(crtc_state))
1651		return PTR_ERR(crtc_state);
1652
1653	primary_state = drm_atomic_get_plane_state(state, crtc->primary);
1654	if (IS_ERR(primary_state))
1655		return PTR_ERR(primary_state);
1656
1657	if (!set->mode) {
1658		WARN_ON(set->fb);
1659		WARN_ON(set->num_connectors);
1660
1661		ret = drm_atomic_set_mode_for_crtc(crtc_state, NULL);
1662		if (ret != 0)
1663			return ret;
1664
1665		crtc_state->active = false;
1666
1667		ret = drm_atomic_set_crtc_for_plane(primary_state, NULL);
1668		if (ret != 0)
1669			return ret;
1670
1671		drm_atomic_set_fb_for_plane(primary_state, NULL);
1672
1673		goto commit;
1674	}
1675
1676	WARN_ON(!set->fb);
1677	WARN_ON(!set->num_connectors);
1678
1679	ret = drm_atomic_set_mode_for_crtc(crtc_state, set->mode);
1680	if (ret != 0)
1681		return ret;
1682
1683	crtc_state->active = true;
1684
1685	ret = drm_atomic_set_crtc_for_plane(primary_state, crtc);
1686	if (ret != 0)
1687		return ret;
1688
1689	drm_mode_get_hv_timing(set->mode, &hdisplay, &vdisplay);
1690
1691	drm_atomic_set_fb_for_plane(primary_state, set->fb);
1692	primary_state->crtc_x = 0;
1693	primary_state->crtc_y = 0;
1694	primary_state->crtc_w = hdisplay;
1695	primary_state->crtc_h = vdisplay;
1696	primary_state->src_x = set->x << 16;
1697	primary_state->src_y = set->y << 16;
1698	if (drm_rotation_90_or_270(primary_state->rotation)) {
1699		primary_state->src_w = vdisplay << 16;
1700		primary_state->src_h = hdisplay << 16;
1701	} else {
1702		primary_state->src_w = hdisplay << 16;
1703		primary_state->src_h = vdisplay << 16;
1704	}
1705
1706commit:
1707	ret = update_output_state(state, set);
1708	if (ret)
1709		return ret;
1710
1711	return 0;
1712}
1713EXPORT_SYMBOL(__drm_atomic_helper_set_config);
1714
1715static void drm_atomic_private_obj_print_state(struct drm_printer *p,
1716					       const struct drm_private_state *state)
1717{
1718	struct drm_private_obj *obj = state->obj;
1719
1720	if (obj->funcs->atomic_print_state)
1721		obj->funcs->atomic_print_state(p, state);
1722}
1723
1724/**
1725 * drm_atomic_print_new_state - prints drm atomic state
1726 * @state: atomic configuration to check
1727 * @p: drm printer
1728 *
1729 * This functions prints the drm atomic state snapshot using the drm printer
1730 * which is passed to it. This snapshot can be used for debugging purposes.
1731 *
1732 * Note that this function looks into the new state objects and hence its not
1733 * safe to be used after the call to drm_atomic_helper_commit_hw_done().
1734 */
1735void drm_atomic_print_new_state(const struct drm_atomic_state *state,
1736		struct drm_printer *p)
1737{
 
1738	struct drm_plane *plane;
1739	struct drm_plane_state *plane_state;
1740	struct drm_crtc *crtc;
1741	struct drm_crtc_state *crtc_state;
1742	struct drm_connector *connector;
1743	struct drm_connector_state *connector_state;
1744	struct drm_private_obj *obj;
1745	struct drm_private_state *obj_state;
1746	int i;
1747
1748	if (!p) {
1749		drm_err(state->dev, "invalid drm printer\n");
1750		return;
1751	}
1752
1753	drm_dbg_atomic(state->dev, "checking %p\n", state);
1754
1755	for_each_new_plane_in_state(state, plane, plane_state, i)
1756		drm_atomic_plane_print_state(p, plane_state);
1757
1758	for_each_new_crtc_in_state(state, crtc, crtc_state, i)
1759		drm_atomic_crtc_print_state(p, crtc_state);
1760
1761	for_each_new_connector_in_state(state, connector, connector_state, i)
1762		drm_atomic_connector_print_state(p, connector_state);
1763
1764	for_each_new_private_obj_in_state(state, obj, obj_state, i)
1765		drm_atomic_private_obj_print_state(p, obj_state);
1766}
1767EXPORT_SYMBOL(drm_atomic_print_new_state);
1768
1769static void __drm_state_dump(struct drm_device *dev, struct drm_printer *p,
1770			     bool take_locks)
1771{
1772	struct drm_mode_config *config = &dev->mode_config;
1773	struct drm_plane *plane;
1774	struct drm_crtc *crtc;
1775	struct drm_connector *connector;
1776	struct drm_connector_list_iter conn_iter;
1777	struct drm_private_obj *obj;
1778
1779	if (!drm_drv_uses_atomic_modeset(dev))
1780		return;
1781
1782	list_for_each_entry(plane, &config->plane_list, head) {
1783		if (take_locks)
1784			drm_modeset_lock(&plane->mutex, NULL);
1785		drm_atomic_plane_print_state(p, plane->state);
1786		if (take_locks)
1787			drm_modeset_unlock(&plane->mutex);
1788	}
1789
1790	list_for_each_entry(crtc, &config->crtc_list, head) {
1791		if (take_locks)
1792			drm_modeset_lock(&crtc->mutex, NULL);
1793		drm_atomic_crtc_print_state(p, crtc->state);
1794		if (take_locks)
1795			drm_modeset_unlock(&crtc->mutex);
1796	}
1797
1798	drm_connector_list_iter_begin(dev, &conn_iter);
1799	if (take_locks)
1800		drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
1801	drm_for_each_connector_iter(connector, &conn_iter)
1802		drm_atomic_connector_print_state(p, connector->state);
1803	if (take_locks)
1804		drm_modeset_unlock(&dev->mode_config.connection_mutex);
1805	drm_connector_list_iter_end(&conn_iter);
1806
1807	list_for_each_entry(obj, &config->privobj_list, head) {
1808		if (take_locks)
1809			drm_modeset_lock(&obj->lock, NULL);
1810		drm_atomic_private_obj_print_state(p, obj->state);
1811		if (take_locks)
1812			drm_modeset_unlock(&obj->lock);
1813	}
1814}
1815
1816/**
1817 * drm_state_dump - dump entire device atomic state
1818 * @dev: the drm device
1819 * @p: where to print the state to
1820 *
1821 * Just for debugging.  Drivers might want an option to dump state
1822 * to dmesg in case of error irq's.  (Hint, you probably want to
1823 * ratelimit this!)
1824 *
1825 * The caller must wrap this drm_modeset_lock_all_ctx() and
1826 * drm_modeset_drop_locks(). If this is called from error irq handler, it should
1827 * not be enabled by default - if you are debugging errors you might
1828 * not care that this is racey, but calling this without all modeset locks held
1829 * is inherently unsafe.
1830 */
1831void drm_state_dump(struct drm_device *dev, struct drm_printer *p)
1832{
1833	__drm_state_dump(dev, p, false);
1834}
1835EXPORT_SYMBOL(drm_state_dump);
1836
1837#ifdef CONFIG_DEBUG_FS
1838static int drm_state_info(struct seq_file *m, void *data)
1839{
1840	struct drm_debugfs_entry *entry = m->private;
1841	struct drm_device *dev = entry->dev;
1842	struct drm_printer p = drm_seq_file_printer(m);
1843
1844	__drm_state_dump(dev, &p, true);
1845
1846	return 0;
1847}
1848
1849/* any use in debugfs files to dump individual planes/crtc/etc? */
1850static const struct drm_debugfs_info drm_atomic_debugfs_list[] = {
1851	{"state", drm_state_info, 0},
1852};
1853
1854void drm_atomic_debugfs_init(struct drm_device *dev)
1855{
1856	drm_debugfs_add_files(dev, drm_atomic_debugfs_list,
1857			      ARRAY_SIZE(drm_atomic_debugfs_list));
 
1858}
1859#endif