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