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