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