Home | History | Annotate | Line # | Download | only in drm
drm_crtc_helper.c revision 1.1.1.1.4.2
      1 /*
      2  * Copyright (c) 2006-2008 Intel Corporation
      3  * Copyright (c) 2007 Dave Airlie <airlied (at) 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 (at) anholt.net>
     28  *      Dave Airlie <airlied (at) linux.ie>
     29  *      Jesse Barnes <jesse.barnes (at) intel.com>
     30  */
     31 
     32 #include <linux/export.h>
     33 #include <linux/moduleparam.h>
     34 
     35 #include <drm/drmP.h>
     36 #include <drm/drm_crtc.h>
     37 #include <drm/drm_fourcc.h>
     38 #include <drm/drm_crtc_helper.h>
     39 #include <drm/drm_fb_helper.h>
     40 #include <drm/drm_edid.h>
     41 
     42 /**
     43  * drm_helper_move_panel_connectors_to_head() - move panels to the front in the
     44  * 						connector list
     45  * @dev: drm device to operate on
     46  *
     47  * Some userspace presumes that the first connected connector is the main
     48  * display, where it's supposed to display e.g. the login screen. For
     49  * laptops, this should be the main panel. Use this function to sort all
     50  * (eDP/LVDS) panels to the front of the connector list, instead of
     51  * painstakingly trying to initialize them in the right order.
     52  */
     53 void drm_helper_move_panel_connectors_to_head(struct drm_device *dev)
     54 {
     55 	struct drm_connector *connector, *tmp;
     56 	struct list_head panel_list;
     57 
     58 	INIT_LIST_HEAD(&panel_list);
     59 
     60 	list_for_each_entry_safe(connector, tmp,
     61 				 &dev->mode_config.connector_list, head) {
     62 		if (connector->connector_type == DRM_MODE_CONNECTOR_LVDS ||
     63 		    connector->connector_type == DRM_MODE_CONNECTOR_eDP)
     64 			list_move_tail(&connector->head, &panel_list);
     65 	}
     66 
     67 	list_splice(&panel_list, &dev->mode_config.connector_list);
     68 }
     69 EXPORT_SYMBOL(drm_helper_move_panel_connectors_to_head);
     70 
     71 static bool drm_kms_helper_poll = true;
     72 module_param_named(poll, drm_kms_helper_poll, bool, 0600);
     73 
     74 static void drm_mode_validate_flag(struct drm_connector *connector,
     75 				   int flags)
     76 {
     77 	struct drm_display_mode *mode;
     78 
     79 	if (flags == (DRM_MODE_FLAG_DBLSCAN | DRM_MODE_FLAG_INTERLACE))
     80 		return;
     81 
     82 	list_for_each_entry(mode, &connector->modes, head) {
     83 		if ((mode->flags & DRM_MODE_FLAG_INTERLACE) &&
     84 				!(flags & DRM_MODE_FLAG_INTERLACE))
     85 			mode->status = MODE_NO_INTERLACE;
     86 		if ((mode->flags & DRM_MODE_FLAG_DBLSCAN) &&
     87 				!(flags & DRM_MODE_FLAG_DBLSCAN))
     88 			mode->status = MODE_NO_DBLESCAN;
     89 	}
     90 
     91 	return;
     92 }
     93 
     94 /**
     95  * drm_helper_probe_single_connector_modes - get complete set of display modes
     96  * @connector: connector to probe
     97  * @maxX: max width for modes
     98  * @maxY: max height for modes
     99  *
    100  * LOCKING:
    101  * Caller must hold mode config lock.
    102  *
    103  * Based on the helper callbacks implemented by @connector try to detect all
    104  * valid modes.  Modes will first be added to the connector's probed_modes list,
    105  * then culled (based on validity and the @maxX, @maxY parameters) and put into
    106  * the normal modes list.
    107  *
    108  * Intended to be use as a generic implementation of the ->probe() @connector
    109  * callback for drivers that use the crtc helpers for output mode filtering and
    110  * detection.
    111  *
    112  * RETURNS:
    113  * Number of modes found on @connector.
    114  */
    115 int drm_helper_probe_single_connector_modes(struct drm_connector *connector,
    116 					    uint32_t maxX, uint32_t maxY)
    117 {
    118 	struct drm_device *dev = connector->dev;
    119 	struct drm_display_mode *mode;
    120 	struct drm_connector_helper_funcs *connector_funcs =
    121 		connector->helper_private;
    122 	int count = 0;
    123 	int mode_flags = 0;
    124 
    125 	DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n", connector->base.id,
    126 			drm_get_connector_name(connector));
    127 	/* set all modes to the unverified state */
    128 	list_for_each_entry(mode, &connector->modes, head)
    129 		mode->status = MODE_UNVERIFIED;
    130 
    131 	if (connector->force) {
    132 		if (connector->force == DRM_FORCE_ON)
    133 			connector->status = connector_status_connected;
    134 		else
    135 			connector->status = connector_status_disconnected;
    136 		if (connector->funcs->force)
    137 			connector->funcs->force(connector);
    138 	} else {
    139 		connector->status = connector->funcs->detect(connector, true);
    140 	}
    141 
    142 	/* Re-enable polling in case the global poll config changed. */
    143 	if (drm_kms_helper_poll != dev->mode_config.poll_running)
    144 		drm_kms_helper_poll_enable(dev);
    145 
    146 	dev->mode_config.poll_running = drm_kms_helper_poll;
    147 
    148 	if (connector->status == connector_status_disconnected) {
    149 		DRM_DEBUG_KMS("[CONNECTOR:%d:%s] disconnected\n",
    150 			connector->base.id, drm_get_connector_name(connector));
    151 		drm_mode_connector_update_edid_property(connector, NULL);
    152 		goto prune;
    153 	}
    154 
    155 #ifdef CONFIG_DRM_LOAD_EDID_FIRMWARE
    156 	count = drm_load_edid_firmware(connector);
    157 	if (count == 0)
    158 #endif
    159 		count = (*connector_funcs->get_modes)(connector);
    160 
    161 	if (count == 0 && connector->status == connector_status_connected)
    162 		count = drm_add_modes_noedid(connector, 1024, 768);
    163 	if (count == 0)
    164 		goto prune;
    165 
    166 	drm_mode_connector_list_update(connector);
    167 
    168 	if (maxX && maxY)
    169 		drm_mode_validate_size(dev, &connector->modes, maxX,
    170 				       maxY, 0);
    171 
    172 	if (connector->interlace_allowed)
    173 		mode_flags |= DRM_MODE_FLAG_INTERLACE;
    174 	if (connector->doublescan_allowed)
    175 		mode_flags |= DRM_MODE_FLAG_DBLSCAN;
    176 	drm_mode_validate_flag(connector, mode_flags);
    177 
    178 	list_for_each_entry(mode, &connector->modes, head) {
    179 		if (mode->status == MODE_OK)
    180 			mode->status = connector_funcs->mode_valid(connector,
    181 								   mode);
    182 	}
    183 
    184 prune:
    185 	drm_mode_prune_invalid(dev, &connector->modes, true);
    186 
    187 	if (list_empty(&connector->modes))
    188 		return 0;
    189 
    190 	drm_mode_sort(&connector->modes);
    191 
    192 	DRM_DEBUG_KMS("[CONNECTOR:%d:%s] probed modes :\n", connector->base.id,
    193 			drm_get_connector_name(connector));
    194 	list_for_each_entry(mode, &connector->modes, head) {
    195 		mode->vrefresh = drm_mode_vrefresh(mode);
    196 
    197 		drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V);
    198 		drm_mode_debug_printmodeline(mode);
    199 	}
    200 
    201 	return count;
    202 }
    203 EXPORT_SYMBOL(drm_helper_probe_single_connector_modes);
    204 
    205 /**
    206  * drm_helper_encoder_in_use - check if a given encoder is in use
    207  * @encoder: encoder to check
    208  *
    209  * LOCKING:
    210  * Caller must hold mode config lock.
    211  *
    212  * Walk @encoders's DRM device's mode_config and see if it's in use.
    213  *
    214  * RETURNS:
    215  * True if @encoder is part of the mode_config, false otherwise.
    216  */
    217 bool drm_helper_encoder_in_use(struct drm_encoder *encoder)
    218 {
    219 	struct drm_connector *connector;
    220 	struct drm_device *dev = encoder->dev;
    221 	list_for_each_entry(connector, &dev->mode_config.connector_list, head)
    222 		if (connector->encoder == encoder)
    223 			return true;
    224 	return false;
    225 }
    226 EXPORT_SYMBOL(drm_helper_encoder_in_use);
    227 
    228 /**
    229  * drm_helper_crtc_in_use - check if a given CRTC is in a mode_config
    230  * @crtc: CRTC to check
    231  *
    232  * LOCKING:
    233  * Caller must hold mode config lock.
    234  *
    235  * Walk @crtc's DRM device's mode_config and see if it's in use.
    236  *
    237  * RETURNS:
    238  * True if @crtc is part of the mode_config, false otherwise.
    239  */
    240 bool drm_helper_crtc_in_use(struct drm_crtc *crtc)
    241 {
    242 	struct drm_encoder *encoder;
    243 	struct drm_device *dev = crtc->dev;
    244 	/* FIXME: Locking around list access? */
    245 	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head)
    246 		if (encoder->crtc == crtc && drm_helper_encoder_in_use(encoder))
    247 			return true;
    248 	return false;
    249 }
    250 EXPORT_SYMBOL(drm_helper_crtc_in_use);
    251 
    252 static void
    253 drm_encoder_disable(struct drm_encoder *encoder)
    254 {
    255 	struct drm_encoder_helper_funcs *encoder_funcs = encoder->helper_private;
    256 
    257 	if (encoder_funcs->disable)
    258 		(*encoder_funcs->disable)(encoder);
    259 	else
    260 		(*encoder_funcs->dpms)(encoder, DRM_MODE_DPMS_OFF);
    261 }
    262 
    263 /**
    264  * drm_helper_disable_unused_functions - disable unused objects
    265  * @dev: DRM device
    266  *
    267  * LOCKING:
    268  * Caller must hold mode config lock.
    269  *
    270  * If an connector or CRTC isn't part of @dev's mode_config, it can be disabled
    271  * by calling its dpms function, which should power it off.
    272  */
    273 void drm_helper_disable_unused_functions(struct drm_device *dev)
    274 {
    275 	struct drm_encoder *encoder;
    276 	struct drm_connector *connector;
    277 	struct drm_crtc *crtc;
    278 
    279 	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
    280 		if (!connector->encoder)
    281 			continue;
    282 		if (connector->status == connector_status_disconnected)
    283 			connector->encoder = NULL;
    284 	}
    285 
    286 	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
    287 		if (!drm_helper_encoder_in_use(encoder)) {
    288 			drm_encoder_disable(encoder);
    289 			/* disconnector encoder from any connector */
    290 			encoder->crtc = NULL;
    291 		}
    292 	}
    293 
    294 	list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
    295 		struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
    296 		crtc->enabled = drm_helper_crtc_in_use(crtc);
    297 		if (!crtc->enabled) {
    298 			if (crtc_funcs->disable)
    299 				(*crtc_funcs->disable)(crtc);
    300 			else
    301 				(*crtc_funcs->dpms)(crtc, DRM_MODE_DPMS_OFF);
    302 			crtc->fb = NULL;
    303 		}
    304 	}
    305 }
    306 EXPORT_SYMBOL(drm_helper_disable_unused_functions);
    307 
    308 /**
    309  * drm_encoder_crtc_ok - can a given crtc drive a given encoder?
    310  * @encoder: encoder to test
    311  * @crtc: crtc to test
    312  *
    313  * Return false if @encoder can't be driven by @crtc, true otherwise.
    314  */
    315 static bool drm_encoder_crtc_ok(struct drm_encoder *encoder,
    316 				struct drm_crtc *crtc)
    317 {
    318 	struct drm_device *dev;
    319 	struct drm_crtc *tmp;
    320 	int crtc_mask = 1;
    321 
    322 	WARN(!crtc, "checking null crtc?\n");
    323 
    324 	dev = crtc->dev;
    325 
    326 	list_for_each_entry(tmp, &dev->mode_config.crtc_list, head) {
    327 		if (tmp == crtc)
    328 			break;
    329 		crtc_mask <<= 1;
    330 	}
    331 
    332 	if (encoder->possible_crtcs & crtc_mask)
    333 		return true;
    334 	return false;
    335 }
    336 
    337 /*
    338  * Check the CRTC we're going to map each output to vs. its current
    339  * CRTC.  If they don't match, we have to disable the output and the CRTC
    340  * since the driver will have to re-route things.
    341  */
    342 static void
    343 drm_crtc_prepare_encoders(struct drm_device *dev)
    344 {
    345 	struct drm_encoder_helper_funcs *encoder_funcs;
    346 	struct drm_encoder *encoder;
    347 
    348 	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
    349 		encoder_funcs = encoder->helper_private;
    350 		/* Disable unused encoders */
    351 		if (encoder->crtc == NULL)
    352 			drm_encoder_disable(encoder);
    353 		/* Disable encoders whose CRTC is about to change */
    354 		if (encoder_funcs->get_crtc &&
    355 		    encoder->crtc != (*encoder_funcs->get_crtc)(encoder))
    356 			drm_encoder_disable(encoder);
    357 	}
    358 }
    359 
    360 /**
    361  * drm_crtc_helper_set_mode - internal helper to set a mode
    362  * @crtc: CRTC to program
    363  * @mode: mode to use
    364  * @x: horizontal offset into the surface
    365  * @y: vertical offset into the surface
    366  * @old_fb: old framebuffer, for cleanup
    367  *
    368  * LOCKING:
    369  * Caller must hold mode config lock.
    370  *
    371  * Try to set @mode on @crtc.  Give @crtc and its associated connectors a chance
    372  * to fixup or reject the mode prior to trying to set it. This is an internal
    373  * helper that drivers could e.g. use to update properties that require the
    374  * entire output pipe to be disabled and re-enabled in a new configuration. For
    375  * example for changing whether audio is enabled on a hdmi link or for changing
    376  * panel fitter or dither attributes. It is also called by the
    377  * drm_crtc_helper_set_config() helper function to drive the mode setting
    378  * sequence.
    379  *
    380  * RETURNS:
    381  * True if the mode was set successfully, or false otherwise.
    382  */
    383 bool drm_crtc_helper_set_mode(struct drm_crtc *crtc,
    384 			      struct drm_display_mode *mode,
    385 			      int x, int y,
    386 			      struct drm_framebuffer *old_fb)
    387 {
    388 	struct drm_device *dev = crtc->dev;
    389 	struct drm_display_mode *adjusted_mode, saved_mode, saved_hwmode;
    390 	struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
    391 	struct drm_encoder_helper_funcs *encoder_funcs;
    392 	int saved_x, saved_y;
    393 	struct drm_encoder *encoder;
    394 	bool ret = true;
    395 
    396 	crtc->enabled = drm_helper_crtc_in_use(crtc);
    397 	if (!crtc->enabled)
    398 		return true;
    399 
    400 	adjusted_mode = drm_mode_duplicate(dev, mode);
    401 	if (!adjusted_mode)
    402 		return false;
    403 
    404 	saved_hwmode = crtc->hwmode;
    405 	saved_mode = crtc->mode;
    406 	saved_x = crtc->x;
    407 	saved_y = crtc->y;
    408 
    409 	/* Update crtc values up front so the driver can rely on them for mode
    410 	 * setting.
    411 	 */
    412 	crtc->mode = *mode;
    413 	crtc->x = x;
    414 	crtc->y = y;
    415 
    416 	/* Pass our mode to the connectors and the CRTC to give them a chance to
    417 	 * adjust it according to limitations or connector properties, and also
    418 	 * a chance to reject the mode entirely.
    419 	 */
    420 	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
    421 
    422 		if (encoder->crtc != crtc)
    423 			continue;
    424 		encoder_funcs = encoder->helper_private;
    425 		if (!(ret = encoder_funcs->mode_fixup(encoder, mode,
    426 						      adjusted_mode))) {
    427 			DRM_DEBUG_KMS("Encoder fixup failed\n");
    428 			goto done;
    429 		}
    430 	}
    431 
    432 	if (!(ret = crtc_funcs->mode_fixup(crtc, mode, adjusted_mode))) {
    433 		DRM_DEBUG_KMS("CRTC fixup failed\n");
    434 		goto done;
    435 	}
    436 	DRM_DEBUG_KMS("[CRTC:%d]\n", crtc->base.id);
    437 
    438 	/* Prepare the encoders and CRTCs before setting the mode. */
    439 	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
    440 
    441 		if (encoder->crtc != crtc)
    442 			continue;
    443 		encoder_funcs = encoder->helper_private;
    444 		/* Disable the encoders as the first thing we do. */
    445 		encoder_funcs->prepare(encoder);
    446 	}
    447 
    448 	drm_crtc_prepare_encoders(dev);
    449 
    450 	crtc_funcs->prepare(crtc);
    451 
    452 	/* Set up the DPLL and any encoders state that needs to adjust or depend
    453 	 * on the DPLL.
    454 	 */
    455 	ret = !crtc_funcs->mode_set(crtc, mode, adjusted_mode, x, y, old_fb);
    456 	if (!ret)
    457 	    goto done;
    458 
    459 	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
    460 
    461 		if (encoder->crtc != crtc)
    462 			continue;
    463 
    464 		DRM_DEBUG_KMS("[ENCODER:%d:%s] set [MODE:%d:%s]\n",
    465 			encoder->base.id, drm_get_encoder_name(encoder),
    466 			mode->base.id, mode->name);
    467 		encoder_funcs = encoder->helper_private;
    468 		encoder_funcs->mode_set(encoder, mode, adjusted_mode);
    469 	}
    470 
    471 	/* Now enable the clocks, plane, pipe, and connectors that we set up. */
    472 	crtc_funcs->commit(crtc);
    473 
    474 	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
    475 
    476 		if (encoder->crtc != crtc)
    477 			continue;
    478 
    479 		encoder_funcs = encoder->helper_private;
    480 		encoder_funcs->commit(encoder);
    481 
    482 	}
    483 
    484 	/* Store real post-adjustment hardware mode. */
    485 	crtc->hwmode = *adjusted_mode;
    486 
    487 	/* Calculate and store various constants which
    488 	 * are later needed by vblank and swap-completion
    489 	 * timestamping. They are derived from true hwmode.
    490 	 */
    491 	drm_calc_timestamping_constants(crtc);
    492 
    493 	/* FIXME: add subpixel order */
    494 done:
    495 	drm_mode_destroy(dev, adjusted_mode);
    496 	if (!ret) {
    497 		crtc->hwmode = saved_hwmode;
    498 		crtc->mode = saved_mode;
    499 		crtc->x = saved_x;
    500 		crtc->y = saved_y;
    501 	}
    502 
    503 	return ret;
    504 }
    505 EXPORT_SYMBOL(drm_crtc_helper_set_mode);
    506 
    507 
    508 static int
    509 drm_crtc_helper_disable(struct drm_crtc *crtc)
    510 {
    511 	struct drm_device *dev = crtc->dev;
    512 	struct drm_connector *connector;
    513 	struct drm_encoder *encoder;
    514 
    515 	/* Decouple all encoders and their attached connectors from this crtc */
    516 	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
    517 		if (encoder->crtc != crtc)
    518 			continue;
    519 
    520 		list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
    521 			if (connector->encoder != encoder)
    522 				continue;
    523 
    524 			connector->encoder = NULL;
    525 		}
    526 	}
    527 
    528 	drm_helper_disable_unused_functions(dev);
    529 	return 0;
    530 }
    531 
    532 /**
    533  * drm_crtc_helper_set_config - set a new config from userspace
    534  * @set: mode set configuration
    535  *
    536  * LOCKING:
    537  * Caller must hold mode config lock.
    538  *
    539  * Setup a new configuration, provided by the upper layers (either an ioctl call
    540  * from userspace or internally e.g. from the fbdev suppport code) in @set, and
    541  * enable it. This is the main helper functions for drivers that implement
    542  * kernel mode setting with the crtc helper functions and the assorted
    543  * ->prepare(), ->modeset() and ->commit() helper callbacks.
    544  *
    545  * RETURNS:
    546  * Returns 0 on success, -ERRNO on failure.
    547  */
    548 int drm_crtc_helper_set_config(struct drm_mode_set *set)
    549 {
    550 	struct drm_device *dev;
    551 	struct drm_crtc *save_crtcs, *new_crtc, *crtc;
    552 	struct drm_encoder *save_encoders, *new_encoder, *encoder;
    553 	struct drm_framebuffer *old_fb = NULL;
    554 	bool mode_changed = false; /* if true do a full mode set */
    555 	bool fb_changed = false; /* if true and !mode_changed just do a flip */
    556 	struct drm_connector *save_connectors, *connector;
    557 	int count = 0, ro, fail = 0;
    558 	struct drm_crtc_helper_funcs *crtc_funcs;
    559 	struct drm_mode_set save_set;
    560 	int ret;
    561 	int i;
    562 
    563 	DRM_DEBUG_KMS("\n");
    564 
    565 	if (!set)
    566 		return -EINVAL;
    567 
    568 	if (!set->crtc)
    569 		return -EINVAL;
    570 
    571 	if (!set->crtc->helper_private)
    572 		return -EINVAL;
    573 
    574 	crtc_funcs = set->crtc->helper_private;
    575 
    576 	if (!set->mode)
    577 		set->fb = NULL;
    578 
    579 	if (set->fb) {
    580 		DRM_DEBUG_KMS("[CRTC:%d] [FB:%d] #connectors=%d (x y) (%i %i)\n",
    581 				set->crtc->base.id, set->fb->base.id,
    582 				(int)set->num_connectors, set->x, set->y);
    583 	} else {
    584 		DRM_DEBUG_KMS("[CRTC:%d] [NOFB]\n", set->crtc->base.id);
    585 		return drm_crtc_helper_disable(set->crtc);
    586 	}
    587 
    588 	dev = set->crtc->dev;
    589 
    590 	/* Allocate space for the backup of all (non-pointer) crtc, encoder and
    591 	 * connector data. */
    592 	save_crtcs = kzalloc(dev->mode_config.num_crtc *
    593 			     sizeof(struct drm_crtc), GFP_KERNEL);
    594 	if (!save_crtcs)
    595 		return -ENOMEM;
    596 
    597 	save_encoders = kzalloc(dev->mode_config.num_encoder *
    598 				sizeof(struct drm_encoder), GFP_KERNEL);
    599 	if (!save_encoders) {
    600 		kfree(save_crtcs);
    601 		return -ENOMEM;
    602 	}
    603 
    604 	save_connectors = kzalloc(dev->mode_config.num_connector *
    605 				sizeof(struct drm_connector), GFP_KERNEL);
    606 	if (!save_connectors) {
    607 		kfree(save_crtcs);
    608 		kfree(save_encoders);
    609 		return -ENOMEM;
    610 	}
    611 
    612 	/* Copy data. Note that driver private data is not affected.
    613 	 * Should anything bad happen only the expected state is
    614 	 * restored, not the drivers personal bookkeeping.
    615 	 */
    616 	count = 0;
    617 	list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
    618 		save_crtcs[count++] = *crtc;
    619 	}
    620 
    621 	count = 0;
    622 	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
    623 		save_encoders[count++] = *encoder;
    624 	}
    625 
    626 	count = 0;
    627 	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
    628 		save_connectors[count++] = *connector;
    629 	}
    630 
    631 	save_set.crtc = set->crtc;
    632 	save_set.mode = &set->crtc->mode;
    633 	save_set.x = set->crtc->x;
    634 	save_set.y = set->crtc->y;
    635 	save_set.fb = set->crtc->fb;
    636 
    637 	/* We should be able to check here if the fb has the same properties
    638 	 * and then just flip_or_move it */
    639 	if (set->crtc->fb != set->fb) {
    640 		/* If we have no fb then treat it as a full mode set */
    641 		if (set->crtc->fb == NULL) {
    642 			DRM_DEBUG_KMS("crtc has no fb, full mode set\n");
    643 			mode_changed = true;
    644 		} else if (set->fb == NULL) {
    645 			mode_changed = true;
    646 		} else if (set->fb->depth != set->crtc->fb->depth) {
    647 			mode_changed = true;
    648 		} else if (set->fb->bits_per_pixel !=
    649 			   set->crtc->fb->bits_per_pixel) {
    650 			mode_changed = true;
    651 		} else
    652 			fb_changed = true;
    653 	}
    654 
    655 	if (set->x != set->crtc->x || set->y != set->crtc->y)
    656 		fb_changed = true;
    657 
    658 	if (set->mode && !drm_mode_equal(set->mode, &set->crtc->mode)) {
    659 		DRM_DEBUG_KMS("modes are different, full mode set\n");
    660 		drm_mode_debug_printmodeline(&set->crtc->mode);
    661 		drm_mode_debug_printmodeline(set->mode);
    662 		mode_changed = true;
    663 	}
    664 
    665 	/* a) traverse passed in connector list and get encoders for them */
    666 	count = 0;
    667 	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
    668 		struct drm_connector_helper_funcs *connector_funcs =
    669 			connector->helper_private;
    670 		new_encoder = connector->encoder;
    671 		for (ro = 0; ro < set->num_connectors; ro++) {
    672 			if (set->connectors[ro] == connector) {
    673 				new_encoder = connector_funcs->best_encoder(connector);
    674 				/* if we can't get an encoder for a connector
    675 				   we are setting now - then fail */
    676 				if (new_encoder == NULL)
    677 					/* don't break so fail path works correct */
    678 					fail = 1;
    679 				break;
    680 			}
    681 		}
    682 
    683 		if (new_encoder != connector->encoder) {
    684 			DRM_DEBUG_KMS("encoder changed, full mode switch\n");
    685 			mode_changed = true;
    686 			/* If the encoder is reused for another connector, then
    687 			 * the appropriate crtc will be set later.
    688 			 */
    689 			if (connector->encoder)
    690 				connector->encoder->crtc = NULL;
    691 			connector->encoder = new_encoder;
    692 		}
    693 	}
    694 
    695 	if (fail) {
    696 		ret = -EINVAL;
    697 		goto fail;
    698 	}
    699 
    700 	count = 0;
    701 	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
    702 		if (!connector->encoder)
    703 			continue;
    704 
    705 		if (connector->encoder->crtc == set->crtc)
    706 			new_crtc = NULL;
    707 		else
    708 			new_crtc = connector->encoder->crtc;
    709 
    710 		for (ro = 0; ro < set->num_connectors; ro++) {
    711 			if (set->connectors[ro] == connector)
    712 				new_crtc = set->crtc;
    713 		}
    714 
    715 		/* Make sure the new CRTC will work with the encoder */
    716 		if (new_crtc &&
    717 		    !drm_encoder_crtc_ok(connector->encoder, new_crtc)) {
    718 			ret = -EINVAL;
    719 			goto fail;
    720 		}
    721 		if (new_crtc != connector->encoder->crtc) {
    722 			DRM_DEBUG_KMS("crtc changed, full mode switch\n");
    723 			mode_changed = true;
    724 			connector->encoder->crtc = new_crtc;
    725 		}
    726 		if (new_crtc) {
    727 			DRM_DEBUG_KMS("[CONNECTOR:%d:%s] to [CRTC:%d]\n",
    728 				connector->base.id, drm_get_connector_name(connector),
    729 				new_crtc->base.id);
    730 		} else {
    731 			DRM_DEBUG_KMS("[CONNECTOR:%d:%s] to [NOCRTC]\n",
    732 				connector->base.id, drm_get_connector_name(connector));
    733 		}
    734 	}
    735 
    736 	/* mode_set_base is not a required function */
    737 	if (fb_changed && !crtc_funcs->mode_set_base)
    738 		mode_changed = true;
    739 
    740 	if (mode_changed) {
    741 		set->crtc->enabled = drm_helper_crtc_in_use(set->crtc);
    742 		if (set->crtc->enabled) {
    743 			DRM_DEBUG_KMS("attempting to set mode from"
    744 					" userspace\n");
    745 			drm_mode_debug_printmodeline(set->mode);
    746 			old_fb = set->crtc->fb;
    747 			set->crtc->fb = set->fb;
    748 			if (!drm_crtc_helper_set_mode(set->crtc, set->mode,
    749 						      set->x, set->y,
    750 						      old_fb)) {
    751 				DRM_ERROR("failed to set mode on [CRTC:%d]\n",
    752 					  set->crtc->base.id);
    753 				set->crtc->fb = old_fb;
    754 				ret = -EINVAL;
    755 				goto fail;
    756 			}
    757 			DRM_DEBUG_KMS("Setting connector DPMS state to on\n");
    758 			for (i = 0; i < set->num_connectors; i++) {
    759 				DRM_DEBUG_KMS("\t[CONNECTOR:%d:%s] set DPMS on\n", set->connectors[i]->base.id,
    760 					      drm_get_connector_name(set->connectors[i]));
    761 				set->connectors[i]->funcs->dpms(set->connectors[i], DRM_MODE_DPMS_ON);
    762 			}
    763 		}
    764 		drm_helper_disable_unused_functions(dev);
    765 	} else if (fb_changed) {
    766 		set->crtc->x = set->x;
    767 		set->crtc->y = set->y;
    768 
    769 		old_fb = set->crtc->fb;
    770 		if (set->crtc->fb != set->fb)
    771 			set->crtc->fb = set->fb;
    772 		ret = crtc_funcs->mode_set_base(set->crtc,
    773 						set->x, set->y, old_fb);
    774 		if (ret != 0) {
    775 			set->crtc->fb = old_fb;
    776 			goto fail;
    777 		}
    778 	}
    779 
    780 	kfree(save_connectors);
    781 	kfree(save_encoders);
    782 	kfree(save_crtcs);
    783 	return 0;
    784 
    785 fail:
    786 	/* Restore all previous data. */
    787 	count = 0;
    788 	list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
    789 		*crtc = save_crtcs[count++];
    790 	}
    791 
    792 	count = 0;
    793 	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
    794 		*encoder = save_encoders[count++];
    795 	}
    796 
    797 	count = 0;
    798 	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
    799 		*connector = save_connectors[count++];
    800 	}
    801 
    802 	/* Try to restore the config */
    803 	if (mode_changed &&
    804 	    !drm_crtc_helper_set_mode(save_set.crtc, save_set.mode, save_set.x,
    805 				      save_set.y, save_set.fb))
    806 		DRM_ERROR("failed to restore config after modeset failure\n");
    807 
    808 	kfree(save_connectors);
    809 	kfree(save_encoders);
    810 	kfree(save_crtcs);
    811 	return ret;
    812 }
    813 EXPORT_SYMBOL(drm_crtc_helper_set_config);
    814 
    815 static int drm_helper_choose_encoder_dpms(struct drm_encoder *encoder)
    816 {
    817 	int dpms = DRM_MODE_DPMS_OFF;
    818 	struct drm_connector *connector;
    819 	struct drm_device *dev = encoder->dev;
    820 
    821 	list_for_each_entry(connector, &dev->mode_config.connector_list, head)
    822 		if (connector->encoder == encoder)
    823 			if (connector->dpms < dpms)
    824 				dpms = connector->dpms;
    825 	return dpms;
    826 }
    827 
    828 static int drm_helper_choose_crtc_dpms(struct drm_crtc *crtc)
    829 {
    830 	int dpms = DRM_MODE_DPMS_OFF;
    831 	struct drm_connector *connector;
    832 	struct drm_device *dev = crtc->dev;
    833 
    834 	list_for_each_entry(connector, &dev->mode_config.connector_list, head)
    835 		if (connector->encoder && connector->encoder->crtc == crtc)
    836 			if (connector->dpms < dpms)
    837 				dpms = connector->dpms;
    838 	return dpms;
    839 }
    840 
    841 /**
    842  * drm_helper_connector_dpms() - connector dpms helper implementation
    843  * @connector: affected connector
    844  * @mode: DPMS mode
    845  *
    846  * This is the main helper function provided by the crtc helper framework for
    847  * implementing the DPMS connector attribute. It computes the new desired DPMS
    848  * state for all encoders and crtcs in the output mesh and calls the ->dpms()
    849  * callback provided by the driver appropriately.
    850  */
    851 void drm_helper_connector_dpms(struct drm_connector *connector, int mode)
    852 {
    853 	struct drm_encoder *encoder = connector->encoder;
    854 	struct drm_crtc *crtc = encoder ? encoder->crtc : NULL;
    855 	int old_dpms;
    856 
    857 	if (mode == connector->dpms)
    858 		return;
    859 
    860 	old_dpms = connector->dpms;
    861 	connector->dpms = mode;
    862 
    863 	/* from off to on, do crtc then encoder */
    864 	if (mode < old_dpms) {
    865 		if (crtc) {
    866 			struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
    867 			if (crtc_funcs->dpms)
    868 				(*crtc_funcs->dpms) (crtc,
    869 						     drm_helper_choose_crtc_dpms(crtc));
    870 		}
    871 		if (encoder) {
    872 			struct drm_encoder_helper_funcs *encoder_funcs = encoder->helper_private;
    873 			if (encoder_funcs->dpms)
    874 				(*encoder_funcs->dpms) (encoder,
    875 							drm_helper_choose_encoder_dpms(encoder));
    876 		}
    877 	}
    878 
    879 	/* from on to off, do encoder then crtc */
    880 	if (mode > old_dpms) {
    881 		if (encoder) {
    882 			struct drm_encoder_helper_funcs *encoder_funcs = encoder->helper_private;
    883 			if (encoder_funcs->dpms)
    884 				(*encoder_funcs->dpms) (encoder,
    885 							drm_helper_choose_encoder_dpms(encoder));
    886 		}
    887 		if (crtc) {
    888 			struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
    889 			if (crtc_funcs->dpms)
    890 				(*crtc_funcs->dpms) (crtc,
    891 						     drm_helper_choose_crtc_dpms(crtc));
    892 		}
    893 	}
    894 
    895 	return;
    896 }
    897 EXPORT_SYMBOL(drm_helper_connector_dpms);
    898 
    899 int drm_helper_mode_fill_fb_struct(struct drm_framebuffer *fb,
    900 				   struct drm_mode_fb_cmd2 *mode_cmd)
    901 {
    902 	int i;
    903 
    904 	fb->width = mode_cmd->width;
    905 	fb->height = mode_cmd->height;
    906 	for (i = 0; i < 4; i++) {
    907 		fb->pitches[i] = mode_cmd->pitches[i];
    908 		fb->offsets[i] = mode_cmd->offsets[i];
    909 	}
    910 	drm_fb_get_bpp_depth(mode_cmd->pixel_format, &fb->depth,
    911 				    &fb->bits_per_pixel);
    912 	fb->pixel_format = mode_cmd->pixel_format;
    913 
    914 	return 0;
    915 }
    916 EXPORT_SYMBOL(drm_helper_mode_fill_fb_struct);
    917 
    918 int drm_helper_resume_force_mode(struct drm_device *dev)
    919 {
    920 	struct drm_crtc *crtc;
    921 	struct drm_encoder *encoder;
    922 	struct drm_encoder_helper_funcs *encoder_funcs;
    923 	struct drm_crtc_helper_funcs *crtc_funcs;
    924 	int ret;
    925 
    926 	list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
    927 
    928 		if (!crtc->enabled)
    929 			continue;
    930 
    931 		ret = drm_crtc_helper_set_mode(crtc, &crtc->mode,
    932 					       crtc->x, crtc->y, crtc->fb);
    933 
    934 		if (ret == false)
    935 			DRM_ERROR("failed to set mode on crtc %p\n", crtc);
    936 
    937 		/* Turn off outputs that were already powered off */
    938 		if (drm_helper_choose_crtc_dpms(crtc)) {
    939 			list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
    940 
    941 				if(encoder->crtc != crtc)
    942 					continue;
    943 
    944 				encoder_funcs = encoder->helper_private;
    945 				if (encoder_funcs->dpms)
    946 					(*encoder_funcs->dpms) (encoder,
    947 								drm_helper_choose_encoder_dpms(encoder));
    948 			}
    949 
    950 			crtc_funcs = crtc->helper_private;
    951 			if (crtc_funcs->dpms)
    952 				(*crtc_funcs->dpms) (crtc,
    953 						     drm_helper_choose_crtc_dpms(crtc));
    954 		}
    955 	}
    956 	/* disable the unused connectors while restoring the modesetting */
    957 	drm_helper_disable_unused_functions(dev);
    958 	return 0;
    959 }
    960 EXPORT_SYMBOL(drm_helper_resume_force_mode);
    961 
    962 void drm_kms_helper_hotplug_event(struct drm_device *dev)
    963 {
    964 	/* send a uevent + call fbdev */
    965 	drm_sysfs_hotplug_event(dev);
    966 	if (dev->mode_config.funcs->output_poll_changed)
    967 		dev->mode_config.funcs->output_poll_changed(dev);
    968 }
    969 EXPORT_SYMBOL(drm_kms_helper_hotplug_event);
    970 
    971 #define DRM_OUTPUT_POLL_PERIOD (10*HZ)
    972 static void output_poll_execute(struct work_struct *work)
    973 {
    974 	struct delayed_work *delayed_work = to_delayed_work(work);
    975 	struct drm_device *dev = container_of(delayed_work, struct drm_device, mode_config.output_poll_work);
    976 	struct drm_connector *connector;
    977 	enum drm_connector_status old_status;
    978 	bool repoll = false, changed = false;
    979 
    980 	if (!drm_kms_helper_poll)
    981 		return;
    982 
    983 	mutex_lock(&dev->mode_config.mutex);
    984 	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
    985 
    986 		/* Ignore forced connectors. */
    987 		if (connector->force)
    988 			continue;
    989 
    990 		/* Ignore HPD capable connectors and connectors where we don't
    991 		 * want any hotplug detection at all for polling. */
    992 		if (!connector->polled || connector->polled == DRM_CONNECTOR_POLL_HPD)
    993 			continue;
    994 
    995 		repoll = true;
    996 
    997 		old_status = connector->status;
    998 		/* if we are connected and don't want to poll for disconnect
    999 		   skip it */
   1000 		if (old_status == connector_status_connected &&
   1001 		    !(connector->polled & DRM_CONNECTOR_POLL_DISCONNECT))
   1002 			continue;
   1003 
   1004 		connector->status = connector->funcs->detect(connector, false);
   1005 		DRM_DEBUG_KMS("[CONNECTOR:%d:%s] status updated from %d to %d\n",
   1006 			      connector->base.id,
   1007 			      drm_get_connector_name(connector),
   1008 			      old_status, connector->status);
   1009 		if (old_status != connector->status)
   1010 			changed = true;
   1011 	}
   1012 
   1013 	mutex_unlock(&dev->mode_config.mutex);
   1014 
   1015 	if (changed)
   1016 		drm_kms_helper_hotplug_event(dev);
   1017 
   1018 	if (repoll)
   1019 		schedule_delayed_work(delayed_work, DRM_OUTPUT_POLL_PERIOD);
   1020 }
   1021 
   1022 void drm_kms_helper_poll_disable(struct drm_device *dev)
   1023 {
   1024 	if (!dev->mode_config.poll_enabled)
   1025 		return;
   1026 	cancel_delayed_work_sync(&dev->mode_config.output_poll_work);
   1027 }
   1028 EXPORT_SYMBOL(drm_kms_helper_poll_disable);
   1029 
   1030 void drm_kms_helper_poll_enable(struct drm_device *dev)
   1031 {
   1032 	bool poll = false;
   1033 	struct drm_connector *connector;
   1034 
   1035 	if (!dev->mode_config.poll_enabled || !drm_kms_helper_poll)
   1036 		return;
   1037 
   1038 	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
   1039 		if (connector->polled & (DRM_CONNECTOR_POLL_CONNECT |
   1040 					 DRM_CONNECTOR_POLL_DISCONNECT))
   1041 			poll = true;
   1042 	}
   1043 
   1044 	if (poll)
   1045 		schedule_delayed_work(&dev->mode_config.output_poll_work, DRM_OUTPUT_POLL_PERIOD);
   1046 }
   1047 EXPORT_SYMBOL(drm_kms_helper_poll_enable);
   1048 
   1049 void drm_kms_helper_poll_init(struct drm_device *dev)
   1050 {
   1051 	INIT_DELAYED_WORK(&dev->mode_config.output_poll_work, output_poll_execute);
   1052 	dev->mode_config.poll_enabled = true;
   1053 
   1054 	drm_kms_helper_poll_enable(dev);
   1055 }
   1056 EXPORT_SYMBOL(drm_kms_helper_poll_init);
   1057 
   1058 void drm_kms_helper_poll_fini(struct drm_device *dev)
   1059 {
   1060 	drm_kms_helper_poll_disable(dev);
   1061 }
   1062 EXPORT_SYMBOL(drm_kms_helper_poll_fini);
   1063 
   1064 void drm_helper_hpd_irq_event(struct drm_device *dev)
   1065 {
   1066 	struct drm_connector *connector;
   1067 	enum drm_connector_status old_status;
   1068 	bool changed = false;
   1069 
   1070 	if (!dev->mode_config.poll_enabled)
   1071 		return;
   1072 
   1073 	mutex_lock(&dev->mode_config.mutex);
   1074 	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
   1075 
   1076 		/* Only handle HPD capable connectors. */
   1077 		if (!(connector->polled & DRM_CONNECTOR_POLL_HPD))
   1078 			continue;
   1079 
   1080 		old_status = connector->status;
   1081 
   1082 		connector->status = connector->funcs->detect(connector, false);
   1083 		DRM_DEBUG_KMS("[CONNECTOR:%d:%s] status updated from %d to %d\n",
   1084 			      connector->base.id,
   1085 			      drm_get_connector_name(connector),
   1086 			      old_status, connector->status);
   1087 		if (old_status != connector->status)
   1088 			changed = true;
   1089 	}
   1090 
   1091 	mutex_unlock(&dev->mode_config.mutex);
   1092 
   1093 	if (changed)
   1094 		drm_kms_helper_hotplug_event(dev);
   1095 }
   1096 EXPORT_SYMBOL(drm_helper_hpd_irq_event);
   1097