1/*
   2 * Copyright (c) 2006-2008 Intel Corporation
   3 * Copyright (c) 2007 Dave Airlie <airlied@linux.ie>
   4 *
   5 * DRM core CRTC related functions
   6 *
   7 * Permission to use, copy, modify, distribute, and sell this software and its
   8 * documentation for any purpose is hereby granted without fee, provided that
   9 * the above copyright notice appear in all copies and that both that copyright
  10 * notice and this permission notice appear in supporting documentation, and
  11 * that the name of the copyright holders not be used in advertising or
  12 * publicity pertaining to distribution of the software without specific,
  13 * written prior permission.  The copyright holders make no representations
  14 * about the suitability of this software for any purpose.  It is provided "as
  15 * is" without express or implied warranty.
  16 *
  17 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  18 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  19 * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  20 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  21 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  22 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
  23 * OF THIS SOFTWARE.
  24 *
  25 * Authors:
  26 *      Keith Packard
  27 *	Eric Anholt <eric@anholt.net>
  28 *      Dave Airlie <airlied@linux.ie>
  29 *      Jesse Barnes <jesse.barnes@intel.com>
  30 */
  31
  32#include <linux/export.h>
  33#include <linux/kernel.h>
  34#include <linux/moduleparam.h>
  35
  36#include <drm/drm_atomic.h>
  37#include <drm/drm_atomic_helper.h>
  38#include <drm/drm_atomic_uapi.h>
 
  39#include <drm/drm_crtc.h>
  40#include <drm/drm_crtc_helper.h>
  41#include <drm/drm_drv.h>
  42#include <drm/drm_edid.h>
  43#include <drm/drm_encoder.h>
  44#include <drm/drm_fb_helper.h>
  45#include <drm/drm_fourcc.h>
  46#include <drm/drm_plane_helper.h>
  47#include <drm/drm_print.h>
  48#include <drm/drm_vblank.h>
  49
 
 
  50/**
  51 * DOC: overview
  52 *
  53 * The CRTC modeset helper library provides a default set_config implementation
  54 * in drm_crtc_helper_set_config(). Plus a few other convenience functions using
  55 * the same callbacks which drivers can use to e.g. restore the modeset
  56 * configuration on resume with drm_helper_resume_force_mode().
  57 *
  58 * Note that this helper library doesn't track the current power state of CRTCs
  59 * and encoders. It can call callbacks like &drm_encoder_helper_funcs.dpms even
  60 * though the hardware is already in the desired state. This deficiency has been
  61 * fixed in the atomic helpers.
  62 *
  63 * The driver callbacks are mostly compatible with the atomic modeset helpers,
  64 * except for the handling of the primary plane: Atomic helpers require that the
  65 * primary plane is implemented as a real standalone plane and not directly tied
  66 * to the CRTC state. For easier transition this library provides functions to
  67 * implement the old semantics required by the CRTC helpers using the new plane
  68 * and atomic helper callbacks.
  69 *
  70 * Drivers are strongly urged to convert to the atomic helpers (by way of first
  71 * converting to the plane helpers). New drivers must not use these functions
  72 * but need to implement the atomic interface instead, potentially using the
  73 * atomic helpers for that.
  74 *
  75 * These legacy modeset helpers use the same function table structures as
  76 * all other modesetting helpers. See the documentation for struct
  77 * &drm_crtc_helper_funcs, &struct drm_encoder_helper_funcs and struct
  78 * &drm_connector_helper_funcs.
  79 */
  80
  81/**
  82 * drm_helper_encoder_in_use - check if a given encoder is in use
  83 * @encoder: encoder to check
  84 *
  85 * Checks whether @encoder is with the current mode setting output configuration
  86 * in use by any connector. This doesn't mean that it is actually enabled since
  87 * the DPMS state is tracked separately.
  88 *
  89 * Returns:
  90 * True if @encoder is used, false otherwise.
  91 */
  92bool drm_helper_encoder_in_use(struct drm_encoder *encoder)
  93{
  94	struct drm_connector *connector;
  95	struct drm_connector_list_iter conn_iter;
  96	struct drm_device *dev = encoder->dev;
  97
  98	WARN_ON(drm_drv_uses_atomic_modeset(dev));
  99
 100	/*
 101	 * We can expect this mutex to be locked if we are not panicking.
 102	 * Locking is currently fubar in the panic handler.
 103	 */
 104	if (!oops_in_progress) {
 105		WARN_ON(!mutex_is_locked(&dev->mode_config.mutex));
 106		WARN_ON(!drm_modeset_is_locked(&dev->mode_config.connection_mutex));
 107	}
 108
 109
 110	drm_connector_list_iter_begin(dev, &conn_iter);
 111	drm_for_each_connector_iter(connector, &conn_iter) {
 112		if (connector->encoder == encoder) {
 113			drm_connector_list_iter_end(&conn_iter);
 114			return true;
 115		}
 116	}
 117	drm_connector_list_iter_end(&conn_iter);
 118	return false;
 119}
 120EXPORT_SYMBOL(drm_helper_encoder_in_use);
 121
 122/**
 123 * drm_helper_crtc_in_use - check if a given CRTC is in a mode_config
 124 * @crtc: CRTC to check
 125 *
 126 * Checks whether @crtc is with the current mode setting output configuration
 127 * in use by any connector. This doesn't mean that it is actually enabled since
 128 * the DPMS state is tracked separately.
 129 *
 130 * Returns:
 131 * True if @crtc is used, false otherwise.
 132 */
 133bool drm_helper_crtc_in_use(struct drm_crtc *crtc)
 134{
 135	struct drm_encoder *encoder;
 136	struct drm_device *dev = crtc->dev;
 137
 138	WARN_ON(drm_drv_uses_atomic_modeset(dev));
 139
 140	/*
 141	 * We can expect this mutex to be locked if we are not panicking.
 142	 * Locking is currently fubar in the panic handler.
 143	 */
 144	if (!oops_in_progress)
 145		WARN_ON(!mutex_is_locked(&dev->mode_config.mutex));
 146
 147	drm_for_each_encoder(encoder, dev)
 148		if (encoder->crtc == crtc && drm_helper_encoder_in_use(encoder))
 149			return true;
 150	return false;
 151}
 152EXPORT_SYMBOL(drm_helper_crtc_in_use);
 153
 154static void
 155drm_encoder_disable(struct drm_encoder *encoder)
 156{
 157	const struct drm_encoder_helper_funcs *encoder_funcs = encoder->helper_private;
 158
 159	if (!encoder_funcs)
 160		return;
 161
 162	if (encoder_funcs->disable)
 163		(*encoder_funcs->disable)(encoder);
 164	else if (encoder_funcs->dpms)
 165		(*encoder_funcs->dpms)(encoder, DRM_MODE_DPMS_OFF);
 166}
 167
 168static void __drm_helper_disable_unused_functions(struct drm_device *dev)
 169{
 170	struct drm_encoder *encoder;
 171	struct drm_crtc *crtc;
 172
 173	drm_warn_on_modeset_not_all_locked(dev);
 174
 175	drm_for_each_encoder(encoder, dev) {
 176		if (!drm_helper_encoder_in_use(encoder)) {
 177			drm_encoder_disable(encoder);
 178			/* disconnect encoder from any connector */
 179			encoder->crtc = NULL;
 180		}
 181	}
 182
 183	drm_for_each_crtc(crtc, dev) {
 184		const struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
 
 185		crtc->enabled = drm_helper_crtc_in_use(crtc);
 186		if (!crtc->enabled) {
 187			if (crtc_funcs->disable)
 188				(*crtc_funcs->disable)(crtc);
 189			else
 190				(*crtc_funcs->dpms)(crtc, DRM_MODE_DPMS_OFF);
 191			crtc->primary->fb = NULL;
 192		}
 193	}
 194}
 195
 196/**
 197 * drm_helper_disable_unused_functions - disable unused objects
 198 * @dev: DRM device
 199 *
 200 * This function walks through the entire mode setting configuration of @dev. It
 201 * will remove any CRTC links of unused encoders and encoder links of
 202 * disconnected connectors. Then it will disable all unused encoders and CRTCs
 203 * either by calling their disable callback if available or by calling their
 204 * dpms callback with DRM_MODE_DPMS_OFF.
 205 *
 206 * NOTE:
 207 *
 208 * This function is part of the legacy modeset helper library and will cause
 209 * major confusion with atomic drivers. This is because atomic helpers guarantee
 210 * to never call ->disable() hooks on a disabled function, or ->enable() hooks
 211 * on an enabled functions. drm_helper_disable_unused_functions() on the other
 212 * hand throws such guarantees into the wind and calls disable hooks
 213 * unconditionally on unused functions.
 214 */
 215void drm_helper_disable_unused_functions(struct drm_device *dev)
 216{
 217	WARN_ON(drm_drv_uses_atomic_modeset(dev));
 218
 219	drm_modeset_lock_all(dev);
 220	__drm_helper_disable_unused_functions(dev);
 221	drm_modeset_unlock_all(dev);
 222}
 223EXPORT_SYMBOL(drm_helper_disable_unused_functions);
 224
 225/*
 226 * Check the CRTC we're going to map each output to vs. its current
 227 * CRTC.  If they don't match, we have to disable the output and the CRTC
 228 * since the driver will have to re-route things.
 229 */
 230static void
 231drm_crtc_prepare_encoders(struct drm_device *dev)
 232{
 233	const struct drm_encoder_helper_funcs *encoder_funcs;
 234	struct drm_encoder *encoder;
 235
 236	drm_for_each_encoder(encoder, dev) {
 237		encoder_funcs = encoder->helper_private;
 238		if (!encoder_funcs)
 239			continue;
 240
 241		/* Disable unused encoders */
 242		if (encoder->crtc == NULL)
 243			drm_encoder_disable(encoder);
 244		/* Disable encoders whose CRTC is about to change */
 245		if (encoder_funcs->get_crtc &&
 246		    encoder->crtc != (*encoder_funcs->get_crtc)(encoder))
 247			drm_encoder_disable(encoder);
 248	}
 249}
 250
 251/**
 252 * drm_crtc_helper_set_mode - internal helper to set a mode
 253 * @crtc: CRTC to program
 254 * @mode: mode to use
 255 * @x: horizontal offset into the surface
 256 * @y: vertical offset into the surface
 257 * @old_fb: old framebuffer, for cleanup
 258 *
 259 * Try to set @mode on @crtc.  Give @crtc and its associated connectors a chance
 260 * to fixup or reject the mode prior to trying to set it. This is an internal
 261 * helper that drivers could e.g. use to update properties that require the
 262 * entire output pipe to be disabled and re-enabled in a new configuration. For
 263 * example for changing whether audio is enabled on a hdmi link or for changing
 264 * panel fitter or dither attributes. It is also called by the
 265 * drm_crtc_helper_set_config() helper function to drive the mode setting
 266 * sequence.
 267 *
 268 * Returns:
 269 * True if the mode was set successfully, false otherwise.
 270 */
 271bool drm_crtc_helper_set_mode(struct drm_crtc *crtc,
 272			      struct drm_display_mode *mode,
 273			      int x, int y,
 274			      struct drm_framebuffer *old_fb)
 275{
 276	struct drm_device *dev = crtc->dev;
 277	struct drm_display_mode *adjusted_mode, saved_mode, saved_hwmode;
 278	const struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
 279	const struct drm_encoder_helper_funcs *encoder_funcs;
 280	int saved_x, saved_y;
 281	bool saved_enabled;
 282	struct drm_encoder *encoder;
 283	bool ret = true;
 284
 285	WARN_ON(drm_drv_uses_atomic_modeset(dev));
 286
 287	drm_warn_on_modeset_not_all_locked(dev);
 288
 289	saved_enabled = crtc->enabled;
 290	crtc->enabled = drm_helper_crtc_in_use(crtc);
 291	if (!crtc->enabled)
 292		return true;
 293
 294	adjusted_mode = drm_mode_duplicate(dev, mode);
 295	if (!adjusted_mode) {
 296		crtc->enabled = saved_enabled;
 297		return false;
 298	}
 299
 300	saved_mode = crtc->mode;
 301	saved_hwmode = crtc->hwmode;
 302	saved_x = crtc->x;
 303	saved_y = crtc->y;
 304
 305	/* Update crtc values up front so the driver can rely on them for mode
 306	 * setting.
 307	 */
 308	crtc->mode = *mode;
 309	crtc->x = x;
 310	crtc->y = y;
 311
 312	/* Pass our mode to the connectors and the CRTC to give them a chance to
 313	 * adjust it according to limitations or connector properties, and also
 314	 * a chance to reject the mode entirely.
 315	 */
 316	drm_for_each_encoder(encoder, dev) {
 317
 318		if (encoder->crtc != crtc)
 319			continue;
 320
 321		encoder_funcs = encoder->helper_private;
 322		if (!encoder_funcs)
 323			continue;
 324
 325		encoder_funcs = encoder->helper_private;
 326		if (encoder_funcs->mode_fixup) {
 327			if (!(ret = encoder_funcs->mode_fixup(encoder, mode,
 328							      adjusted_mode))) {
 329				DRM_DEBUG_KMS("Encoder fixup failed\n");
 330				goto done;
 331			}
 332		}
 333	}
 334
 335	if (crtc_funcs->mode_fixup) {
 336		if (!(ret = crtc_funcs->mode_fixup(crtc, mode,
 337						adjusted_mode))) {
 338			DRM_DEBUG_KMS("CRTC fixup failed\n");
 339			goto done;
 340		}
 341	}
 342	DRM_DEBUG_KMS("[CRTC:%d:%s]\n", crtc->base.id, crtc->name);
 343
 344	crtc->hwmode = *adjusted_mode;
 345
 346	/* Prepare the encoders and CRTCs before setting the mode. */
 347	drm_for_each_encoder(encoder, dev) {
 348
 349		if (encoder->crtc != crtc)
 350			continue;
 351
 352		encoder_funcs = encoder->helper_private;
 353		if (!encoder_funcs)
 354			continue;
 355
 356		/* Disable the encoders as the first thing we do. */
 357		if (encoder_funcs->prepare)
 358			encoder_funcs->prepare(encoder);
 359	}
 360
 361	drm_crtc_prepare_encoders(dev);
 362
 363	crtc_funcs->prepare(crtc);
 364
 365	/* Set up the DPLL and any encoders state that needs to adjust or depend
 366	 * on the DPLL.
 367	 */
 368	ret = !crtc_funcs->mode_set(crtc, mode, adjusted_mode, x, y, old_fb);
 369	if (!ret)
 370	    goto done;
 371
 372	drm_for_each_encoder(encoder, dev) {
 373
 374		if (encoder->crtc != crtc)
 375			continue;
 376
 377		encoder_funcs = encoder->helper_private;
 378		if (!encoder_funcs)
 379			continue;
 380
 381		DRM_DEBUG_KMS("[ENCODER:%d:%s] set [MODE:%s]\n",
 382			encoder->base.id, encoder->name, mode->name);
 383		if (encoder_funcs->mode_set)
 384			encoder_funcs->mode_set(encoder, mode, adjusted_mode);
 385	}
 386
 387	/* Now enable the clocks, plane, pipe, and connectors that we set up. */
 388	crtc_funcs->commit(crtc);
 389
 390	drm_for_each_encoder(encoder, dev) {
 391
 392		if (encoder->crtc != crtc)
 393			continue;
 394
 395		encoder_funcs = encoder->helper_private;
 396		if (!encoder_funcs)
 397			continue;
 398
 399		if (encoder_funcs->commit)
 400			encoder_funcs->commit(encoder);
 401	}
 402
 403	/* Calculate and store various constants which
 404	 * are later needed by vblank and swap-completion
 405	 * timestamping. They are derived from true hwmode.
 406	 */
 407	drm_calc_timestamping_constants(crtc, &crtc->hwmode);
 408
 409	/* FIXME: add subpixel order */
 410done:
 411	drm_mode_destroy(dev, adjusted_mode);
 412	if (!ret) {
 413		crtc->enabled = saved_enabled;
 414		crtc->mode = saved_mode;
 415		crtc->hwmode = saved_hwmode;
 416		crtc->x = saved_x;
 417		crtc->y = saved_y;
 418	}
 419
 420	return ret;
 421}
 422EXPORT_SYMBOL(drm_crtc_helper_set_mode);
 423
 424static void
 425drm_crtc_helper_disable(struct drm_crtc *crtc)
 426{
 427	struct drm_device *dev = crtc->dev;
 428	struct drm_connector *connector;
 429	struct drm_encoder *encoder;
 430
 431	/* Decouple all encoders and their attached connectors from this crtc */
 432	drm_for_each_encoder(encoder, dev) {
 433		struct drm_connector_list_iter conn_iter;
 434
 435		if (encoder->crtc != crtc)
 436			continue;
 437
 438		drm_connector_list_iter_begin(dev, &conn_iter);
 439		drm_for_each_connector_iter(connector, &conn_iter) {
 440			if (connector->encoder != encoder)
 441				continue;
 442
 443			connector->encoder = NULL;
 444
 445			/*
 446			 * drm_helper_disable_unused_functions() ought to be
 447			 * doing this, but since we've decoupled the encoder
 448			 * from the connector above, the required connection
 449			 * between them is henceforth no longer available.
 450			 */
 451			connector->dpms = DRM_MODE_DPMS_OFF;
 452
 453			/* we keep a reference while the encoder is bound */
 454			drm_connector_put(connector);
 455		}
 456		drm_connector_list_iter_end(&conn_iter);
 457	}
 458
 459	__drm_helper_disable_unused_functions(dev);
 460}
 461
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 462/**
 463 * drm_crtc_helper_set_config - set a new config from userspace
 464 * @set: mode set configuration
 465 * @ctx: lock acquire context, not used here
 466 *
 467 * The drm_crtc_helper_set_config() helper function implements the of
 468 * &drm_crtc_funcs.set_config callback for drivers using the legacy CRTC
 469 * helpers.
 470 *
 471 * It first tries to locate the best encoder for each connector by calling the
 472 * connector @drm_connector_helper_funcs.best_encoder helper operation.
 473 *
 474 * After locating the appropriate encoders, the helper function will call the
 475 * mode_fixup encoder and CRTC helper operations to adjust the requested mode,
 476 * or reject it completely in which case an error will be returned to the
 477 * application. If the new configuration after mode adjustment is identical to
 478 * the current configuration the helper function will return without performing
 479 * any other operation.
 480 *
 481 * If the adjusted mode is identical to the current mode but changes to the
 482 * frame buffer need to be applied, the drm_crtc_helper_set_config() function
 483 * will call the CRTC &drm_crtc_helper_funcs.mode_set_base helper operation.
 484 *
 485 * If the adjusted mode differs from the current mode, or if the
 486 * ->mode_set_base() helper operation is not provided, the helper function
 487 * performs a full mode set sequence by calling the ->prepare(), ->mode_set()
 488 * and ->commit() CRTC and encoder helper operations, in that order.
 489 * Alternatively it can also use the dpms and disable helper operations. For
 490 * details see &struct drm_crtc_helper_funcs and struct
 491 * &drm_encoder_helper_funcs.
 492 *
 493 * This function is deprecated.  New drivers must implement atomic modeset
 494 * support, for which this function is unsuitable. Instead drivers should use
 495 * drm_atomic_helper_set_config().
 496 *
 497 * Returns:
 498 * Returns 0 on success, negative errno numbers on failure.
 499 */
 500int drm_crtc_helper_set_config(struct drm_mode_set *set,
 501			       struct drm_modeset_acquire_ctx *ctx)
 502{
 503	struct drm_device *dev;
 504	struct drm_crtc **save_encoder_crtcs, *new_crtc;
 505	struct drm_encoder **save_connector_encoders, *new_encoder, *encoder;
 506	bool mode_changed = false; /* if true do a full mode set */
 507	bool fb_changed = false; /* if true and !mode_changed just do a flip */
 508	struct drm_connector *connector;
 509	struct drm_connector_list_iter conn_iter;
 510	int count = 0, ro, fail = 0;
 511	const struct drm_crtc_helper_funcs *crtc_funcs;
 512	struct drm_mode_set save_set;
 513	int ret;
 514	int i;
 515
 516	DRM_DEBUG_KMS("\n");
 517
 518	BUG_ON(!set);
 519	BUG_ON(!set->crtc);
 520	BUG_ON(!set->crtc->helper_private);
 521
 522	/* Enforce sane interface api - has been abused by the fb helper. */
 523	BUG_ON(!set->mode && set->fb);
 524	BUG_ON(set->fb && set->num_connectors == 0);
 525
 526	crtc_funcs = set->crtc->helper_private;
 527
 528	dev = set->crtc->dev;
 529	WARN_ON(drm_drv_uses_atomic_modeset(dev));
 530
 531	if (!set->mode)
 532		set->fb = NULL;
 533
 534	if (set->fb) {
 535		DRM_DEBUG_KMS("[CRTC:%d:%s] [FB:%d] #connectors=%d (x y) (%i %i)\n",
 536			      set->crtc->base.id, set->crtc->name,
 537			      set->fb->base.id,
 538			      (int)set->num_connectors, set->x, set->y);
 539	} else {
 540		DRM_DEBUG_KMS("[CRTC:%d:%s] [NOFB]\n",
 541			      set->crtc->base.id, set->crtc->name);
 542		drm_crtc_helper_disable(set->crtc);
 543		return 0;
 544	}
 545
 546	drm_warn_on_modeset_not_all_locked(dev);
 547
 548	/*
 549	 * Allocate space for the backup of all (non-pointer) encoder and
 550	 * connector data.
 551	 */
 552	save_encoder_crtcs = kcalloc(dev->mode_config.num_encoder,
 553				sizeof(struct drm_crtc *), GFP_KERNEL);
 554	if (!save_encoder_crtcs)
 555		return -ENOMEM;
 556
 557	save_connector_encoders = kcalloc(dev->mode_config.num_connector,
 558				sizeof(struct drm_encoder *), GFP_KERNEL);
 559	if (!save_connector_encoders) {
 560		kfree(save_encoder_crtcs);
 561		return -ENOMEM;
 562	}
 563
 564	/*
 565	 * Copy data. Note that driver private data is not affected.
 566	 * Should anything bad happen only the expected state is
 567	 * restored, not the drivers personal bookkeeping.
 568	 */
 569	count = 0;
 570	drm_for_each_encoder(encoder, dev) {
 571		save_encoder_crtcs[count++] = encoder->crtc;
 572	}
 573
 574	count = 0;
 575	drm_connector_list_iter_begin(dev, &conn_iter);
 576	drm_for_each_connector_iter(connector, &conn_iter)
 577		save_connector_encoders[count++] = connector->encoder;
 578	drm_connector_list_iter_end(&conn_iter);
 579
 580	save_set.crtc = set->crtc;
 581	save_set.mode = &set->crtc->mode;
 582	save_set.x = set->crtc->x;
 583	save_set.y = set->crtc->y;
 584	save_set.fb = set->crtc->primary->fb;
 585
 586	/* We should be able to check here if the fb has the same properties
 587	 * and then just flip_or_move it */
 588	if (set->crtc->primary->fb != set->fb) {
 589		/* If we have no fb then treat it as a full mode set */
 590		if (set->crtc->primary->fb == NULL) {
 591			DRM_DEBUG_KMS("crtc has no fb, full mode set\n");
 592			mode_changed = true;
 593		} else if (set->fb->format != set->crtc->primary->fb->format) {
 594			mode_changed = true;
 595		} else
 596			fb_changed = true;
 597	}
 598
 599	if (set->x != set->crtc->x || set->y != set->crtc->y)
 600		fb_changed = true;
 601
 602	if (!drm_mode_equal(set->mode, &set->crtc->mode)) {
 603		DRM_DEBUG_KMS("modes are different, full mode set\n");
 604		drm_mode_debug_printmodeline(&set->crtc->mode);
 605		drm_mode_debug_printmodeline(set->mode);
 606		mode_changed = true;
 607	}
 608
 609	/* take a reference on all unbound connectors in set, reuse the
 610	 * already taken reference for bound connectors
 611	 */
 612	for (ro = 0; ro < set->num_connectors; ro++) {
 613		if (set->connectors[ro]->encoder)
 614			continue;
 615		drm_connector_get(set->connectors[ro]);
 616	}
 617
 618	/* a) traverse passed in connector list and get encoders for them */
 619	count = 0;
 620	drm_connector_list_iter_begin(dev, &conn_iter);
 621	drm_for_each_connector_iter(connector, &conn_iter) {
 622		const struct drm_connector_helper_funcs *connector_funcs =
 623			connector->helper_private;
 624		new_encoder = connector->encoder;
 625		for (ro = 0; ro < set->num_connectors; ro++) {
 626			if (set->connectors[ro] == connector) {
 627				new_encoder = connector_funcs->best_encoder(connector);
 
 
 
 
 628				/* if we can't get an encoder for a connector
 629				   we are setting now - then fail */
 630				if (new_encoder == NULL)
 631					/* don't break so fail path works correct */
 632					fail = 1;
 633
 634				if (connector->dpms != DRM_MODE_DPMS_ON) {
 635					DRM_DEBUG_KMS("connector dpms not on, full mode switch\n");
 636					mode_changed = true;
 637				}
 638
 639				break;
 640			}
 641		}
 642
 643		if (new_encoder != connector->encoder) {
 644			DRM_DEBUG_KMS("encoder changed, full mode switch\n");
 645			mode_changed = true;
 646			/* If the encoder is reused for another connector, then
 647			 * the appropriate crtc will be set later.
 648			 */
 649			if (connector->encoder)
 650				connector->encoder->crtc = NULL;
 651			connector->encoder = new_encoder;
 652		}
 653	}
 654	drm_connector_list_iter_end(&conn_iter);
 655
 656	if (fail) {
 657		ret = -EINVAL;
 658		goto fail;
 659	}
 660
 661	count = 0;
 662	drm_connector_list_iter_begin(dev, &conn_iter);
 663	drm_for_each_connector_iter(connector, &conn_iter) {
 664		if (!connector->encoder)
 665			continue;
 666
 667		if (connector->encoder->crtc == set->crtc)
 668			new_crtc = NULL;
 669		else
 670			new_crtc = connector->encoder->crtc;
 671
 672		for (ro = 0; ro < set->num_connectors; ro++) {
 673			if (set->connectors[ro] == connector)
 674				new_crtc = set->crtc;
 675		}
 676
 677		/* Make sure the new CRTC will work with the encoder */
 678		if (new_crtc &&
 679		    !drm_encoder_crtc_ok(connector->encoder, new_crtc)) {
 680			ret = -EINVAL;
 681			drm_connector_list_iter_end(&conn_iter);
 682			goto fail;
 683		}
 684		if (new_crtc != connector->encoder->crtc) {
 685			DRM_DEBUG_KMS("crtc changed, full mode switch\n");
 686			mode_changed = true;
 687			connector->encoder->crtc = new_crtc;
 688		}
 689		if (new_crtc) {
 690			DRM_DEBUG_KMS("[CONNECTOR:%d:%s] to [CRTC:%d:%s]\n",
 691				      connector->base.id, connector->name,
 692				      new_crtc->base.id, new_crtc->name);
 693		} else {
 694			DRM_DEBUG_KMS("[CONNECTOR:%d:%s] to [NOCRTC]\n",
 695				      connector->base.id, connector->name);
 696		}
 697	}
 698	drm_connector_list_iter_end(&conn_iter);
 699
 700	/* mode_set_base is not a required function */
 701	if (fb_changed && !crtc_funcs->mode_set_base)
 702		mode_changed = true;
 703
 704	if (mode_changed) {
 705		if (drm_helper_crtc_in_use(set->crtc)) {
 706			DRM_DEBUG_KMS("attempting to set mode from"
 707					" userspace\n");
 708			drm_mode_debug_printmodeline(set->mode);
 709			set->crtc->primary->fb = set->fb;
 710			if (!drm_crtc_helper_set_mode(set->crtc, set->mode,
 711						      set->x, set->y,
 712						      save_set.fb)) {
 713				DRM_ERROR("failed to set mode on [CRTC:%d:%s]\n",
 714					  set->crtc->base.id, set->crtc->name);
 715				set->crtc->primary->fb = save_set.fb;
 716				ret = -EINVAL;
 717				goto fail;
 718			}
 719			DRM_DEBUG_KMS("Setting connector DPMS state to on\n");
 720			for (i = 0; i < set->num_connectors; i++) {
 721				DRM_DEBUG_KMS("\t[CONNECTOR:%d:%s] set DPMS on\n", set->connectors[i]->base.id,
 722					      set->connectors[i]->name);
 723				set->connectors[i]->funcs->dpms(set->connectors[i], DRM_MODE_DPMS_ON);
 724			}
 725		}
 726		__drm_helper_disable_unused_functions(dev);
 727	} else if (fb_changed) {
 728		set->crtc->x = set->x;
 729		set->crtc->y = set->y;
 730		set->crtc->primary->fb = set->fb;
 731		ret = crtc_funcs->mode_set_base(set->crtc,
 732						set->x, set->y, save_set.fb);
 733		if (ret != 0) {
 734			set->crtc->x = save_set.x;
 735			set->crtc->y = save_set.y;
 736			set->crtc->primary->fb = save_set.fb;
 737			goto fail;
 738		}
 739	}
 740
 741	kfree(save_connector_encoders);
 742	kfree(save_encoder_crtcs);
 743	return 0;
 744
 745fail:
 746	/* Restore all previous data. */
 747	count = 0;
 748	drm_for_each_encoder(encoder, dev) {
 749		encoder->crtc = save_encoder_crtcs[count++];
 750	}
 751
 752	count = 0;
 753	drm_connector_list_iter_begin(dev, &conn_iter);
 754	drm_for_each_connector_iter(connector, &conn_iter)
 755		connector->encoder = save_connector_encoders[count++];
 756	drm_connector_list_iter_end(&conn_iter);
 757
 758	/* after fail drop reference on all unbound connectors in set, let
 759	 * bound connectors keep their reference
 760	 */
 761	for (ro = 0; ro < set->num_connectors; ro++) {
 762		if (set->connectors[ro]->encoder)
 763			continue;
 764		drm_connector_put(set->connectors[ro]);
 765	}
 766
 767	/* Try to restore the config */
 768	if (mode_changed &&
 769	    !drm_crtc_helper_set_mode(save_set.crtc, save_set.mode, save_set.x,
 770				      save_set.y, save_set.fb))
 771		DRM_ERROR("failed to restore config after modeset failure\n");
 772
 773	kfree(save_connector_encoders);
 774	kfree(save_encoder_crtcs);
 775	return ret;
 776}
 777EXPORT_SYMBOL(drm_crtc_helper_set_config);
 778
 779static int drm_helper_choose_encoder_dpms(struct drm_encoder *encoder)
 780{
 781	int dpms = DRM_MODE_DPMS_OFF;
 782	struct drm_connector *connector;
 783	struct drm_connector_list_iter conn_iter;
 784	struct drm_device *dev = encoder->dev;
 785
 786	drm_connector_list_iter_begin(dev, &conn_iter);
 787	drm_for_each_connector_iter(connector, &conn_iter)
 788		if (connector->encoder == encoder)
 789			if (connector->dpms < dpms)
 790				dpms = connector->dpms;
 791	drm_connector_list_iter_end(&conn_iter);
 792
 793	return dpms;
 794}
 795
 796/* Helper which handles bridge ordering around encoder dpms */
 797static void drm_helper_encoder_dpms(struct drm_encoder *encoder, int mode)
 798{
 799	const struct drm_encoder_helper_funcs *encoder_funcs;
 800
 801	encoder_funcs = encoder->helper_private;
 802	if (!encoder_funcs)
 803		return;
 804
 805	if (encoder_funcs->dpms)
 806		encoder_funcs->dpms(encoder, mode);
 807}
 808
 809static int drm_helper_choose_crtc_dpms(struct drm_crtc *crtc)
 810{
 811	int dpms = DRM_MODE_DPMS_OFF;
 812	struct drm_connector *connector;
 813	struct drm_connector_list_iter conn_iter;
 814	struct drm_device *dev = crtc->dev;
 815
 816	drm_connector_list_iter_begin(dev, &conn_iter);
 817	drm_for_each_connector_iter(connector, &conn_iter)
 818		if (connector->encoder && connector->encoder->crtc == crtc)
 819			if (connector->dpms < dpms)
 820				dpms = connector->dpms;
 821	drm_connector_list_iter_end(&conn_iter);
 822
 823	return dpms;
 824}
 825
 826/**
 827 * drm_helper_connector_dpms() - connector dpms helper implementation
 828 * @connector: affected connector
 829 * @mode: DPMS mode
 830 *
 831 * The drm_helper_connector_dpms() helper function implements the
 832 * &drm_connector_funcs.dpms callback for drivers using the legacy CRTC
 833 * helpers.
 834 *
 835 * This is the main helper function provided by the CRTC helper framework for
 836 * implementing the DPMS connector attribute. It computes the new desired DPMS
 837 * state for all encoders and CRTCs in the output mesh and calls the
 838 * &drm_crtc_helper_funcs.dpms and &drm_encoder_helper_funcs.dpms callbacks
 839 * provided by the driver.
 840 *
 841 * This function is deprecated.  New drivers must implement atomic modeset
 842 * support, where DPMS is handled in the DRM core.
 843 *
 844 * Returns:
 845 * Always returns 0.
 846 */
 847int drm_helper_connector_dpms(struct drm_connector *connector, int mode)
 848{
 849	struct drm_encoder *encoder = connector->encoder;
 850	struct drm_crtc *crtc = encoder ? encoder->crtc : NULL;
 851	int old_dpms, encoder_dpms = DRM_MODE_DPMS_OFF;
 852
 853	WARN_ON(drm_drv_uses_atomic_modeset(connector->dev));
 854
 855	if (mode == connector->dpms)
 856		return 0;
 857
 858	old_dpms = connector->dpms;
 859	connector->dpms = mode;
 860
 861	if (encoder)
 862		encoder_dpms = drm_helper_choose_encoder_dpms(encoder);
 863
 864	/* from off to on, do crtc then encoder */
 865	if (mode < old_dpms) {
 866		if (crtc) {
 867			const struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
 
 868			if (crtc_funcs->dpms)
 869				(*crtc_funcs->dpms) (crtc,
 870						     drm_helper_choose_crtc_dpms(crtc));
 871		}
 872		if (encoder)
 873			drm_helper_encoder_dpms(encoder, encoder_dpms);
 874	}
 875
 876	/* from on to off, do encoder then crtc */
 877	if (mode > old_dpms) {
 878		if (encoder)
 879			drm_helper_encoder_dpms(encoder, encoder_dpms);
 880		if (crtc) {
 881			const struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
 
 882			if (crtc_funcs->dpms)
 883				(*crtc_funcs->dpms) (crtc,
 884						     drm_helper_choose_crtc_dpms(crtc));
 885		}
 886	}
 887
 888	return 0;
 889}
 890EXPORT_SYMBOL(drm_helper_connector_dpms);
 891
 892/**
 893 * drm_helper_resume_force_mode - force-restore mode setting configuration
 894 * @dev: drm_device which should be restored
 895 *
 896 * Drivers which use the mode setting helpers can use this function to
 897 * force-restore the mode setting configuration e.g. on resume or when something
 898 * else might have trampled over the hw state (like some overzealous old BIOSen
 899 * tended to do).
 900 *
 901 * This helper doesn't provide a error return value since restoring the old
 902 * config should never fail due to resource allocation issues since the driver
 903 * has successfully set the restored configuration already. Hence this should
 904 * boil down to the equivalent of a few dpms on calls, which also don't provide
 905 * an error code.
 906 *
 907 * Drivers where simply restoring an old configuration again might fail (e.g.
 908 * due to slight differences in allocating shared resources when the
 909 * configuration is restored in a different order than when userspace set it up)
 910 * need to use their own restore logic.
 911 *
 912 * This function is deprecated. New drivers should implement atomic mode-
 913 * setting and use the atomic suspend/resume helpers.
 914 *
 915 * See also:
 916 * drm_atomic_helper_suspend(), drm_atomic_helper_resume()
 917 */
 918void drm_helper_resume_force_mode(struct drm_device *dev)
 919{
 920	struct drm_crtc *crtc;
 921	struct drm_encoder *encoder;
 922	const struct drm_crtc_helper_funcs *crtc_funcs;
 923	int encoder_dpms;
 924	bool ret;
 925
 926	WARN_ON(drm_drv_uses_atomic_modeset(dev));
 927
 928	drm_modeset_lock_all(dev);
 929	drm_for_each_crtc(crtc, dev) {
 930
 931		if (!crtc->enabled)
 932			continue;
 933
 934		ret = drm_crtc_helper_set_mode(crtc, &crtc->mode,
 935					       crtc->x, crtc->y, crtc->primary->fb);
 936
 937		/* Restoring the old config should never fail! */
 938		if (ret == false)
 939			DRM_ERROR("failed to set mode on crtc %p\n", crtc);
 940
 941		/* Turn off outputs that were already powered off */
 942		if (drm_helper_choose_crtc_dpms(crtc)) {
 943			drm_for_each_encoder(encoder, dev) {
 944
 945				if(encoder->crtc != crtc)
 946					continue;
 947
 948				encoder_dpms = drm_helper_choose_encoder_dpms(
 949							encoder);
 950
 951				drm_helper_encoder_dpms(encoder, encoder_dpms);
 952			}
 953
 954			crtc_funcs = crtc->helper_private;
 955			if (crtc_funcs->dpms)
 956				(*crtc_funcs->dpms) (crtc,
 957						     drm_helper_choose_crtc_dpms(crtc));
 958		}
 959	}
 960
 961	/* disable the unused connectors while restoring the modesetting */
 962	__drm_helper_disable_unused_functions(dev);
 963	drm_modeset_unlock_all(dev);
 964}
 965EXPORT_SYMBOL(drm_helper_resume_force_mode);
 966
 967/**
 968 * drm_helper_force_disable_all - Forcibly turn off all enabled CRTCs
 969 * @dev: DRM device whose CRTCs to turn off
 970 *
 971 * Drivers may want to call this on unload to ensure that all displays are
 972 * unlit and the GPU is in a consistent, low power state. Takes modeset locks.
 973 *
 974 * Note: This should only be used by non-atomic legacy drivers. For an atomic
 975 * version look at drm_atomic_helper_shutdown().
 976 *
 977 * Returns:
 978 * Zero on success, error code on failure.
 979 */
 980int drm_helper_force_disable_all(struct drm_device *dev)
 981{
 982	struct drm_crtc *crtc;
 983	int ret = 0;
 984
 985	drm_modeset_lock_all(dev);
 986	drm_for_each_crtc(crtc, dev)
 987		if (crtc->enabled) {
 988			struct drm_mode_set set = {
 989				.crtc = crtc,
 990			};
 991
 992			ret = drm_mode_set_config_internal(&set);
 993			if (ret)
 994				goto out;
 995		}
 996out:
 997	drm_modeset_unlock_all(dev);
 998	return ret;
 999}
1000EXPORT_SYMBOL(drm_helper_force_disable_all);