WebSVN – Kolibri OS – Diff – /drivers/video/drm/drm_crtc_helper.c


/*
 * Copyright (c) 2006-2008 Intel Corporation
 * Copyright (c) 2007 Dave Airlie 
 *
 * DRM core CRTC related functions
 *
 * Permission to use, copy, modify, distribute, and sell this software and its
 * documentation for any purpose is hereby granted without fee, provided that
 * the above copyright notice appear in all copies and that both that copyright
 * notice and this permission notice appear in supporting documentation, and
 * that the name of the copyright holders not be used in advertising or
 * publicity pertaining to distribution of the software without specific,
 * written prior permission.  The copyright holders make no representations
 * about the suitability of this software for any purpose.  It is provided "as
 * is" without express or implied warranty.
 *
 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
 * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
 * OF THIS SOFTWARE.
 *
 * Authors:
 *      Keith Packard
 *	Eric Anholt 
 *      Dave Airlie 
 *      Jesse Barnes 
 */
 
#include 
#include 
 
#include 
#include 
#include 
#include 
#include 
#include 
 
/**
 * drm_helper_move_panel_connectors_to_head() - move panels to the front in the
 * 						connector list
 * @dev: drm device to operate on
 *
 * Some userspace presumes that the first connected connector is the main
 * display, where it's supposed to display e.g. the login screen. For
 * laptops, this should be the main panel. Use this function to sort all
 * (eDP/LVDS) panels to the front of the connector list, instead of
 * painstakingly trying to initialize them in the right order.
 */
void drm_helper_move_panel_connectors_to_head(struct drm_device *dev)
{
	struct drm_connector *connector, *tmp;
	struct list_head panel_list;
 
	INIT_LIST_HEAD(&panel_list);
 
	list_for_each_entry_safe(connector, tmp,
				 &dev->mode_config.connector_list, head) {
		if (connector->connector_type == DRM_MODE_CONNECTOR_LVDS ||
		    connector->connector_type == DRM_MODE_CONNECTOR_eDP)
			list_move_tail(&connector->head, &panel_list);
	}
 
	list_splice(&panel_list, &dev->mode_config.connector_list);
}
EXPORT_SYMBOL(drm_helper_move_panel_connectors_to_head);
 
static bool drm_kms_helper_poll = true;
module_param_named(poll, drm_kms_helper_poll, bool, 0600);
 
static void drm_mode_validate_flag(struct drm_connector *connector,
				   int flags)
{
	struct drm_display_mode *mode;
 
	if (flags == (DRM_MODE_FLAG_DBLSCAN | DRM_MODE_FLAG_INTERLACE))
		return;
 
	list_for_each_entry(mode, &connector->modes, head) {
		if ((mode->flags & DRM_MODE_FLAG_INTERLACE) &&
				!(flags & DRM_MODE_FLAG_INTERLACE))
			mode->status = MODE_NO_INTERLACE;
		if ((mode->flags & DRM_MODE_FLAG_DBLSCAN) &&
				!(flags & DRM_MODE_FLAG_DBLSCAN))
			mode->status = MODE_NO_DBLESCAN;
	}
 
	return;
}
 
/**
 * drm_helper_probe_single_connector_modes - get complete set of display modes
 * @connector: connector to probe
 * @maxX: max width for modes
 * @maxY: max height for modes
 *
 * LOCKING:
 * Caller must hold mode config lock.
 *
 * Based on the helper callbacks implemented by @connector try to detect all
 * valid modes.  Modes will first be added to the connector's probed_modes list,
 * then culled (based on validity and the @maxX, @maxY parameters) and put into
 * the normal modes list.
 *
 * Intended to be use as a generic implementation of the ->probe() @connector
 * callback for drivers that use the crtc helpers for output mode filtering and
 * detection.
 *
 * RETURNS:
 * Number of modes found on @connector.
 */
int drm_helper_probe_single_connector_modes(struct drm_connector *connector,
					    uint32_t maxX, uint32_t maxY)
{
	struct drm_device *dev = connector->dev;
	struct drm_display_mode *mode;
	struct drm_connector_helper_funcs *connector_funcs =
		connector->helper_private;
	int count = 0;
	int mode_flags = 0;
	bool verbose_prune = true;
 
	DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n", connector->base.id,
			drm_get_connector_name(connector));
	/* set all modes to the unverified state */
	list_for_each_entry(mode, &connector->modes, head)
		mode->status = MODE_UNVERIFIED;
 
	if (connector->force) {
		if (connector->force == DRM_FORCE_ON)
			connector->status = connector_status_connected;
		else
			connector->status = connector_status_disconnected;
		if (connector->funcs->force)
			connector->funcs->force(connector);
	} else {
		connector->status = connector->funcs->detect(connector, true);
	}
 
	/* Re-enable polling in case the global poll config changed. */
	if (drm_kms_helper_poll != dev->mode_config.poll_running)
		drm_kms_helper_poll_enable(dev);
 
	dev->mode_config.poll_running = drm_kms_helper_poll;
 
	if (connector->status == connector_status_disconnected) {
		DRM_DEBUG_KMS("[CONNECTOR:%d:%s] disconnected\n",
			connector->base.id, drm_get_connector_name(connector));
		drm_mode_connector_update_edid_property(connector, NULL);
		verbose_prune = false;
		goto prune;
	}
 
#ifdef CONFIG_DRM_LOAD_EDID_FIRMWARE
	count = drm_load_edid_firmware(connector);
	if (count == 0)
#endif
	count = (*connector_funcs->get_modes)(connector);
 
	if (count == 0 && connector->status == connector_status_connected)
		count = drm_add_modes_noedid(connector, 1024, 768);
	if (count == 0)
		goto prune;
 
	drm_mode_connector_list_update(connector);
 
	if (maxX && maxY)
		drm_mode_validate_size(dev, &connector->modes, maxX,
				       maxY, 0);
 
	if (connector->interlace_allowed)
		mode_flags |= DRM_MODE_FLAG_INTERLACE;
	if (connector->doublescan_allowed)
		mode_flags |= DRM_MODE_FLAG_DBLSCAN;
	drm_mode_validate_flag(connector, mode_flags);
 
	list_for_each_entry(mode, &connector->modes, head) {
		if (mode->status == MODE_OK)
			mode->status = connector_funcs->mode_valid(connector,
								   mode);
	}
 
prune:
	drm_mode_prune_invalid(dev, &connector->modes, verbose_prune);
 
	if (list_empty(&connector->modes))
		return 0;
 
	list_for_each_entry(mode, &connector->modes, head)
		mode->vrefresh = drm_mode_vrefresh(mode);
 
	drm_mode_sort(&connector->modes);
 
	DRM_DEBUG_KMS("[CONNECTOR:%d:%s] probed modes :\n", connector->base.id,
				drm_get_connector_name(connector));
	list_for_each_entry(mode, &connector->modes, head) {
		drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V);
		drm_mode_debug_printmodeline(mode);
	}
 
	return count;
}
EXPORT_SYMBOL(drm_helper_probe_single_connector_modes);
 
/**
 * drm_helper_encoder_in_use - check if a given encoder is in use
 * @encoder: encoder to check
 *
 * LOCKING:
 * Caller must hold mode config lock.
 *
 * Walk @encoders's DRM device's mode_config and see if it's in use.
 *
 * RETURNS:
 * True if @encoder is part of the mode_config, false otherwise.
 */
bool drm_helper_encoder_in_use(struct drm_encoder *encoder)
{
	struct drm_connector *connector;
	struct drm_device *dev = encoder->dev;
	list_for_each_entry(connector, &dev->mode_config.connector_list, head)
		if (connector->encoder == encoder)
			return true;
	return false;
}
EXPORT_SYMBOL(drm_helper_encoder_in_use);
 
/**
 * drm_helper_crtc_in_use - check if a given CRTC is in a mode_config
 * @crtc: CRTC to check
 *
 * LOCKING:
 * Caller must hold mode config lock.
 *
 * Walk @crtc's DRM device's mode_config and see if it's in use.
 *
 * RETURNS:
 * True if @crtc is part of the mode_config, false otherwise.
 */
bool drm_helper_crtc_in_use(struct drm_crtc *crtc)
{
	struct drm_encoder *encoder;
	struct drm_device *dev = crtc->dev;
	/* FIXME: Locking around list access? */
	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head)
		if (encoder->crtc == crtc && drm_helper_encoder_in_use(encoder))
			return true;
	return false;
}
EXPORT_SYMBOL(drm_helper_crtc_in_use);
 
static void
drm_encoder_disable(struct drm_encoder *encoder)
{
	struct drm_encoder_helper_funcs *encoder_funcs = encoder->helper_private;
 
	if (encoder->bridge)
		encoder->bridge->funcs->disable(encoder->bridge);
 
	if (encoder_funcs->disable)
		(*encoder_funcs->disable)(encoder);
	else
		(*encoder_funcs->dpms)(encoder, DRM_MODE_DPMS_OFF);
 
	if (encoder->bridge)
		encoder->bridge->funcs->post_disable(encoder->bridge);
}
 
/**
 * drm_helper_disable_unused_functions - disable unused objects
 * @dev: DRM device
 *
 * LOCKING:
 * Caller must hold mode config lock.
 *
 * If an connector or CRTC isn't part of @dev's mode_config, it can be disabled
 * by calling its dpms function, which should power it off.
 */
void drm_helper_disable_unused_functions(struct drm_device *dev)
{
	struct drm_encoder *encoder;
	struct drm_connector *connector;
	struct drm_crtc *crtc;
 
	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
		if (!connector->encoder)
			continue;
		if (connector->status == connector_status_disconnected)
			connector->encoder = NULL;
	}
 
	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
		if (!drm_helper_encoder_in_use(encoder)) {
			drm_encoder_disable(encoder);
			/* disconnector encoder from any connector */
			encoder->crtc = NULL;
		}
	}
 
	list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
		struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
		crtc->enabled = drm_helper_crtc_in_use(crtc);
		if (!crtc->enabled) {
			if (crtc_funcs->disable)
				(*crtc_funcs->disable)(crtc);
			else
				(*crtc_funcs->dpms)(crtc, DRM_MODE_DPMS_OFF);
			crtc->fb = NULL;
		}
	}
}
EXPORT_SYMBOL(drm_helper_disable_unused_functions);
 
/**
 * drm_encoder_crtc_ok - can a given crtc drive a given encoder?
 * @encoder: encoder to test
 * @crtc: crtc to test
 *
 * Return false if @encoder can't be driven by @crtc, true otherwise.
 */
static bool drm_encoder_crtc_ok(struct drm_encoder *encoder,
				struct drm_crtc *crtc)
{
	struct drm_device *dev;
	struct drm_crtc *tmp;
	int crtc_mask = 1;
 
	WARN(!crtc, "checking null crtc?\n");
 
	dev = crtc->dev;
 
	list_for_each_entry(tmp, &dev->mode_config.crtc_list, head) {
		if (tmp == crtc)
			break;
		crtc_mask <<= 1;
	}
 
	if (encoder->possible_crtcs & crtc_mask)
		return true;
	return false;
}
 
/*
 * Check the CRTC we're going to map each output to vs. its current
 * CRTC.  If they don't match, we have to disable the output and the CRTC
 * since the driver will have to re-route things.
 */
static void
drm_crtc_prepare_encoders(struct drm_device *dev)
{
	struct drm_encoder_helper_funcs *encoder_funcs;
	struct drm_encoder *encoder;
 
	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
		encoder_funcs = encoder->helper_private;
		/* Disable unused encoders */
		if (encoder->crtc == NULL)
			drm_encoder_disable(encoder);
		/* Disable encoders whose CRTC is about to change */
		if (encoder_funcs->get_crtc &&
		    encoder->crtc != (*encoder_funcs->get_crtc)(encoder))
			drm_encoder_disable(encoder);
	}
}
 
/**
 * drm_crtc_helper_set_mode - internal helper to set a mode
 * @crtc: CRTC to program
 * @mode: mode to use
 * @x: horizontal offset into the surface
 * @y: vertical offset into the surface
 * @old_fb: old framebuffer, for cleanup
 *
 * LOCKING:
 * Caller must hold mode config lock.
 *
 * Try to set @mode on @crtc.  Give @crtc and its associated connectors a chance
 * to fixup or reject the mode prior to trying to set it. This is an internal
 * helper that drivers could e.g. use to update properties that require the
 * entire output pipe to be disabled and re-enabled in a new configuration. For
 * example for changing whether audio is enabled on a hdmi link or for changing
 * panel fitter or dither attributes. It is also called by the
 * drm_crtc_helper_set_config() helper function to drive the mode setting
 * sequence.
 *
 * RETURNS:
 * True if the mode was set successfully, or false otherwise.
 */
bool drm_crtc_helper_set_mode(struct drm_crtc *crtc,
			      struct drm_display_mode *mode,
			      int x, int y,
			      struct drm_framebuffer *old_fb)
{
	struct drm_device *dev = crtc->dev;
	struct drm_display_mode *adjusted_mode, saved_mode, saved_hwmode;
	struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
	struct drm_encoder_helper_funcs *encoder_funcs;
	int saved_x, saved_y;
	struct drm_encoder *encoder;
	bool ret = true;
 
	crtc->enabled = drm_helper_crtc_in_use(crtc);
	if (!crtc->enabled)
		return true;
 
	adjusted_mode = drm_mode_duplicate(dev, mode);
	if (!adjusted_mode)
		return false;
 
	saved_hwmode = crtc->hwmode;
	saved_mode = crtc->mode;
	saved_x = crtc->x;
	saved_y = crtc->y;
 
	/* Update crtc values up front so the driver can rely on them for mode
	 * setting.
	 */
	crtc->mode = *mode;
	crtc->x = x;
	crtc->y = y;
 
	/* Pass our mode to the connectors and the CRTC to give them a chance to
	 * adjust it according to limitations or connector properties, and also
	 * a chance to reject the mode entirely.
	 */
	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
 
		if (encoder->crtc != crtc)
			continue;
 
		if (encoder->bridge && encoder->bridge->funcs->mode_fixup) {
			ret = encoder->bridge->funcs->mode_fixup(
					encoder->bridge, mode, adjusted_mode);
			if (!ret) {
				DRM_DEBUG_KMS("Bridge fixup failed\n");
				goto done;
			}
		}
 
		encoder_funcs = encoder->helper_private;
		if (!(ret = encoder_funcs->mode_fixup(encoder, mode,
						      adjusted_mode))) {
			DRM_DEBUG_KMS("Encoder fixup failed\n");
			goto done;
		}
	}
 
	if (!(ret = crtc_funcs->mode_fixup(crtc, mode, adjusted_mode))) {
		DRM_DEBUG_KMS("CRTC fixup failed\n");
		goto done;
	}
	DRM_DEBUG_KMS("[CRTC:%d]\n", crtc->base.id);
 
	/* Prepare the encoders and CRTCs before setting the mode. */
	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
 
		if (encoder->crtc != crtc)
			continue;
 
		if (encoder->bridge)
			encoder->bridge->funcs->disable(encoder->bridge);
 
		encoder_funcs = encoder->helper_private;
		/* Disable the encoders as the first thing we do. */
		encoder_funcs->prepare(encoder);
 
		if (encoder->bridge)
			encoder->bridge->funcs->post_disable(encoder->bridge);
	}
 
	drm_crtc_prepare_encoders(dev);
 
	crtc_funcs->prepare(crtc);
 
	/* Set up the DPLL and any encoders state that needs to adjust or depend
	 * on the DPLL.
	 */
	ret = !crtc_funcs->mode_set(crtc, mode, adjusted_mode, x, y, old_fb);
	if (!ret)
	    goto done;
 
	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
 
		if (encoder->crtc != crtc)
			continue;
 
		DRM_DEBUG_KMS("[ENCODER:%d:%s] set [MODE:%d:%s]\n",
			encoder->base.id, drm_get_encoder_name(encoder),
			mode->base.id, mode->name);
		encoder_funcs = encoder->helper_private;
		encoder_funcs->mode_set(encoder, mode, adjusted_mode);
 
		if (encoder->bridge && encoder->bridge->funcs->mode_set)
			encoder->bridge->funcs->mode_set(encoder->bridge, mode,
					adjusted_mode);
	}
 
	/* Now enable the clocks, plane, pipe, and connectors that we set up. */
	crtc_funcs->commit(crtc);
 
	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
 
		if (encoder->crtc != crtc)
			continue;
 
		if (encoder->bridge)
			encoder->bridge->funcs->pre_enable(encoder->bridge);
 
		encoder_funcs = encoder->helper_private;
		encoder_funcs->commit(encoder);
 
		if (encoder->bridge)
			encoder->bridge->funcs->enable(encoder->bridge);
	}
 
	/* Store real post-adjustment hardware mode. */
	crtc->hwmode = *adjusted_mode;
 
	/* Calculate and store various constants which
	 * are later needed by vblank and swap-completion
	 * timestamping. They are derived from true hwmode.
	 */
	drm_calc_timestamping_constants(crtc);
 
	/* FIXME: add subpixel order */
done:
	drm_mode_destroy(dev, adjusted_mode);
	if (!ret) {
		crtc->hwmode = saved_hwmode;
		crtc->mode = saved_mode;
		crtc->x = saved_x;
		crtc->y = saved_y;
	}
 
	return ret;
}
EXPORT_SYMBOL(drm_crtc_helper_set_mode);
 
 
static int
drm_crtc_helper_disable(struct drm_crtc *crtc)
{
	struct drm_device *dev = crtc->dev;
	struct drm_connector *connector;
	struct drm_encoder *encoder;
 
	/* Decouple all encoders and their attached connectors from this crtc */
	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
		if (encoder->crtc != crtc)
			continue;
 
		list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
			if (connector->encoder != encoder)
				continue;
 
			connector->encoder = NULL;
		}
	}
 
	drm_helper_disable_unused_functions(dev);
	return 0;
}
 
/**
 * drm_crtc_helper_set_config - set a new config from userspace
 * @set: mode set configuration
 *
 * LOCKING:
 * Caller must hold mode config lock.
 *
 * Setup a new configuration, provided by the upper layers (either an ioctl call
 * from userspace or internally e.g. from the fbdev suppport code) in @set, and
 * enable it. This is the main helper functions for drivers that implement
 * kernel mode setting with the crtc helper functions and the assorted
 * ->prepare(), ->modeset() and ->commit() helper callbacks.
 *
 * RETURNS:
 * Returns 0 on success, -ERRNO on failure.
 */
int drm_crtc_helper_set_config(struct drm_mode_set *set)
{
	struct drm_device *dev;
	struct drm_crtc *save_crtcs, *new_crtc, *crtc;
	struct drm_encoder *save_encoders, *new_encoder, *encoder;
	struct drm_framebuffer *old_fb = NULL;
	bool mode_changed = false; /* if true do a full mode set */
	bool fb_changed = false; /* if true and !mode_changed just do a flip */
	struct drm_connector *save_connectors, *connector;
	int count = 0, ro, fail = 0;
	struct drm_crtc_helper_funcs *crtc_funcs;
	struct drm_mode_set save_set;
	int ret;
	int i;
 
	DRM_DEBUG_KMS("\n");
 
	BUG_ON(!set);
	BUG_ON(!set->crtc);
	BUG_ON(!set->crtc->helper_private);
 
	/* Enforce sane interface api - has been abused by the fb helper. */
	BUG_ON(!set->mode && set->fb);
	BUG_ON(set->fb && set->num_connectors == 0);
 
	crtc_funcs = set->crtc->helper_private;
 
	if (!set->mode)
		set->fb = NULL;
 
	if (set->fb) {
		DRM_DEBUG_KMS("[CRTC:%d] [FB:%d] #connectors=%d (x y) (%i %i)\n",
				set->crtc->base.id, set->fb->base.id,
		  (int)set->num_connectors, set->x, set->y);
	} else {
		DRM_DEBUG_KMS("[CRTC:%d] [NOFB]\n", set->crtc->base.id);
		return drm_crtc_helper_disable(set->crtc);
	}
 
	dev = set->crtc->dev;
 
	/* Allocate space for the backup of all (non-pointer) crtc, encoder and
	 * connector data. */
	save_crtcs = kzalloc(dev->mode_config.num_crtc *
			     sizeof(struct drm_crtc), GFP_KERNEL);
	if (!save_crtcs)
		return -ENOMEM;
 
	save_encoders = kzalloc(dev->mode_config.num_encoder *
				sizeof(struct drm_encoder), GFP_KERNEL);
	if (!save_encoders) {
		kfree(save_crtcs);
		return -ENOMEM;
	}
 
	save_connectors = kzalloc(dev->mode_config.num_connector *
				sizeof(struct drm_connector), GFP_KERNEL);
	if (!save_connectors) {
		kfree(save_crtcs);
		kfree(save_encoders);
		return -ENOMEM;
	}
 
	/* Copy data. Note that driver private data is not affected.
	 * Should anything bad happen only the expected state is
	 * restored, not the drivers personal bookkeeping.
	 */
	count = 0;
	list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
		save_crtcs[count++] = *crtc;
	}
 
	count = 0;
	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
		save_encoders[count++] = *encoder;
	}
 
	count = 0;
	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
		save_connectors[count++] = *connector;
	}
 
	save_set.crtc = set->crtc;
	save_set.mode = &set->crtc->mode;
	save_set.x = set->crtc->x;
	save_set.y = set->crtc->y;
	save_set.fb = set->crtc->fb;
 
	/* We should be able to check here if the fb has the same properties
	 * and then just flip_or_move it */
	if (set->crtc->fb != set->fb) {
		/* If we have no fb then treat it as a full mode set */
		if (set->crtc->fb == NULL) {
			DRM_DEBUG_KMS("crtc has no fb, full mode set\n");
			mode_changed = true;
		} else if (set->fb == NULL) {
			mode_changed = true;
		} else if (set->fb->pixel_format !=
			   set->crtc->fb->pixel_format) {
			mode_changed = true;
		} else
			fb_changed = true;
	}
 
	if (set->x != set->crtc->x || set->y != set->crtc->y)
		fb_changed = true;
 
	if (set->mode && !drm_mode_equal(set->mode, &set->crtc->mode)) {
		DRM_DEBUG_KMS("modes are different, full mode set\n");
		drm_mode_debug_printmodeline(&set->crtc->mode);
		drm_mode_debug_printmodeline(set->mode);
		mode_changed = true;
	}
 
	/* a) traverse passed in connector list and get encoders for them */
	count = 0;
	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
		struct drm_connector_helper_funcs *connector_funcs =
			connector->helper_private;
		new_encoder = connector->encoder;
		for (ro = 0; ro < set->num_connectors; ro++) {
			if (set->connectors[ro] == connector) {
				new_encoder = connector_funcs->best_encoder(connector);
				/* if we can't get an encoder for a connector
				   we are setting now - then fail */
				if (new_encoder == NULL)
					/* don't break so fail path works correct */
					fail = 1;
				break;
 
				if (connector->dpms != DRM_MODE_DPMS_ON) {
					DRM_DEBUG_KMS("connector dpms not on, full mode switch\n");
					mode_changed = true;
				}
			}
		}
 
		if (new_encoder != connector->encoder) {
			DRM_DEBUG_KMS("encoder changed, full mode switch\n");
			mode_changed = true;
			/* If the encoder is reused for another connector, then
			 * the appropriate crtc will be set later.
			 */
			if (connector->encoder)
				connector->encoder->crtc = NULL;
			connector->encoder = new_encoder;
		}
	}
 
	if (fail) {
		ret = -EINVAL;
		goto fail;
	}
 
	count = 0;
	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
		if (!connector->encoder)
			continue;
 
		if (connector->encoder->crtc == set->crtc)
			new_crtc = NULL;
		else
			new_crtc = connector->encoder->crtc;
 
		for (ro = 0; ro < set->num_connectors; ro++) {
			if (set->connectors[ro] == connector)
				new_crtc = set->crtc;
		}
 
		/* Make sure the new CRTC will work with the encoder */
		if (new_crtc &&
		    !drm_encoder_crtc_ok(connector->encoder, new_crtc)) {
			ret = -EINVAL;
			goto fail;
		}
		if (new_crtc != connector->encoder->crtc) {
			DRM_DEBUG_KMS("crtc changed, full mode switch\n");
			mode_changed = true;
			connector->encoder->crtc = new_crtc;
		}
		if (new_crtc) {
			DRM_DEBUG_KMS("[CONNECTOR:%d:%s] to [CRTC:%d]\n",
				connector->base.id, drm_get_connector_name(connector),
				new_crtc->base.id);
		} else {
			DRM_DEBUG_KMS("[CONNECTOR:%d:%s] to [NOCRTC]\n",
				connector->base.id, drm_get_connector_name(connector));
		}
	}
 
	/* mode_set_base is not a required function */
	if (fb_changed && !crtc_funcs->mode_set_base)
		mode_changed = true;
 
	if (mode_changed) {
		set->crtc->enabled = drm_helper_crtc_in_use(set->crtc);
		if (set->crtc->enabled) {
			DRM_DEBUG_KMS("attempting to set mode from"
					" userspace\n");
			drm_mode_debug_printmodeline(set->mode);
			old_fb = set->crtc->fb;
			set->crtc->fb = set->fb;
			if (!drm_crtc_helper_set_mode(set->crtc, set->mode,
						      set->x, set->y,
						      old_fb)) {
				DRM_ERROR("failed to set mode on [CRTC:%d]\n",
					  set->crtc->base.id);
				set->crtc->fb = old_fb;
				ret = -EINVAL;
				goto fail;
			}
			DRM_DEBUG_KMS("Setting connector DPMS state to on\n");
			for (i = 0; i < set->num_connectors; i++) {
				DRM_DEBUG_KMS("\t[CONNECTOR:%d:%s] set DPMS on\n", set->connectors[i]->base.id,
					      drm_get_connector_name(set->connectors[i]));
				set->connectors[i]->funcs->dpms(set->connectors[i], DRM_MODE_DPMS_ON);
			}
		}
		drm_helper_disable_unused_functions(dev);
	} else if (fb_changed) {
		set->crtc->x = set->x;
		set->crtc->y = set->y;
 
		old_fb = set->crtc->fb;
		if (set->crtc->fb != set->fb)
			set->crtc->fb = set->fb;
		ret = crtc_funcs->mode_set_base(set->crtc,
						set->x, set->y, old_fb);
		if (ret != 0) {
			set->crtc->fb = old_fb;
			goto fail;
	}
	}
 
	kfree(save_connectors);
	kfree(save_encoders);
	kfree(save_crtcs);
	return 0;
 
fail:
	/* Restore all previous data. */
	count = 0;
	list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
		*crtc = save_crtcs[count++];
	}
 
	count = 0;
	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
		*encoder = save_encoders[count++];
	}
 
	count = 0;
	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
		*connector = save_connectors[count++];
	}
 
	/* Try to restore the config */
	if (mode_changed &&
	    !drm_crtc_helper_set_mode(save_set.crtc, save_set.mode, save_set.x,
				      save_set.y, save_set.fb))
		DRM_ERROR("failed to restore config after modeset failure\n");
 
	kfree(save_connectors);
	kfree(save_encoders);
	kfree(save_crtcs);
	return ret;
}
EXPORT_SYMBOL(drm_crtc_helper_set_config);
 
static int drm_helper_choose_encoder_dpms(struct drm_encoder *encoder)
{
	int dpms = DRM_MODE_DPMS_OFF;
	struct drm_connector *connector;
	struct drm_device *dev = encoder->dev;
 
	list_for_each_entry(connector, &dev->mode_config.connector_list, head)
		if (connector->encoder == encoder)
			if (connector->dpms < dpms)
				dpms = connector->dpms;
	return dpms;
}
 
/* Helper which handles bridge ordering around encoder dpms */
static void drm_helper_encoder_dpms(struct drm_encoder *encoder, int mode)
{
	struct drm_bridge *bridge = encoder->bridge;
	struct drm_encoder_helper_funcs *encoder_funcs;
 
	if (bridge) {
		if (mode == DRM_MODE_DPMS_ON)
			bridge->funcs->pre_enable(bridge);
		else
			bridge->funcs->disable(bridge);
	}
 
	encoder_funcs = encoder->helper_private;
	if (encoder_funcs->dpms)
		encoder_funcs->dpms(encoder, mode);
 
	if (bridge) {
		if (mode == DRM_MODE_DPMS_ON)
			bridge->funcs->enable(bridge);
		else
			bridge->funcs->post_disable(bridge);
	}
}
 
static int drm_helper_choose_crtc_dpms(struct drm_crtc *crtc)
{
	int dpms = DRM_MODE_DPMS_OFF;
	struct drm_connector *connector;
	struct drm_device *dev = crtc->dev;
 
	list_for_each_entry(connector, &dev->mode_config.connector_list, head)
		if (connector->encoder && connector->encoder->crtc == crtc)
			if (connector->dpms < dpms)
				dpms = connector->dpms;
	return dpms;
}
 
/**
 * drm_helper_connector_dpms() - connector dpms helper implementation
 * @connector: affected connector
 * @mode: DPMS mode
 *
 * This is the main helper function provided by the crtc helper framework for
 * implementing the DPMS connector attribute. It computes the new desired DPMS
 * state for all encoders and crtcs in the output mesh and calls the ->dpms()
 * callback provided by the driver appropriately.
 */
void drm_helper_connector_dpms(struct drm_connector *connector, int mode)
{
	struct drm_encoder *encoder = connector->encoder;
	struct drm_crtc *crtc = encoder ? encoder->crtc : NULL;
	int old_dpms, encoder_dpms = DRM_MODE_DPMS_OFF;
 
	if (mode == connector->dpms)
		return;
 
	old_dpms = connector->dpms;
	connector->dpms = mode;
 
	if (encoder)
		encoder_dpms = drm_helper_choose_encoder_dpms(encoder);
 
	/* from off to on, do crtc then encoder */
	if (mode < old_dpms) {
		if (crtc) {
			struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
			if (crtc_funcs->dpms)
				(*crtc_funcs->dpms) (crtc,
						     drm_helper_choose_crtc_dpms(crtc));
		}
		if (encoder)
 
 
 
			drm_helper_encoder_dpms(encoder, encoder_dpms);
 
	}
 
	/* from on to off, do encoder then crtc */
	if (mode > old_dpms) {
		if (encoder)
 
 
 
			drm_helper_encoder_dpms(encoder, encoder_dpms);
 
		if (crtc) {
			struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
			if (crtc_funcs->dpms)
				(*crtc_funcs->dpms) (crtc,
						     drm_helper_choose_crtc_dpms(crtc));
		}
	}
 
	return;
}
EXPORT_SYMBOL(drm_helper_connector_dpms);
 
int drm_helper_mode_fill_fb_struct(struct drm_framebuffer *fb,
				   struct drm_mode_fb_cmd2 *mode_cmd)
{
	int i;
 
	fb->width = mode_cmd->width;
	fb->height = mode_cmd->height;
	for (i = 0; i < 4; i++) {
		fb->pitches[i] = mode_cmd->pitches[i];
		fb->offsets[i] = mode_cmd->offsets[i];
	}
	drm_fb_get_bpp_depth(mode_cmd->pixel_format, &fb->depth,
				    &fb->bits_per_pixel);
	fb->pixel_format = mode_cmd->pixel_format;
 
	return 0;
}
EXPORT_SYMBOL(drm_helper_mode_fill_fb_struct);
 
int drm_helper_resume_force_mode(struct drm_device *dev)
{
	struct drm_crtc *crtc;
	struct drm_encoder *encoder;
 
	struct drm_crtc_helper_funcs *crtc_funcs;
	int ret, encoder_dpms;
 
	list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
 
       if (!crtc->enabled)
           continue;
 
		ret = drm_crtc_helper_set_mode(crtc, &crtc->mode,
					       crtc->x, crtc->y, crtc->fb);
 
		if (ret == false)
			DRM_ERROR("failed to set mode on crtc %p\n", crtc);
 
		/* Turn off outputs that were already powered off */
		if (drm_helper_choose_crtc_dpms(crtc)) {
			list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
 
				if(encoder->crtc != crtc)
					continue;
 
				encoder_dpms = drm_helper_choose_encoder_dpms(
 
							encoder);
 
				drm_helper_encoder_dpms(encoder, encoder_dpms);
			}
 
				crtc_funcs = crtc->helper_private;
				if (crtc_funcs->dpms)
					(*crtc_funcs->dpms) (crtc,
							     drm_helper_choose_crtc_dpms(crtc));
			}
		}
	/* disable the unused connectors while restoring the modesetting */
	drm_helper_disable_unused_functions(dev);
	return 0;
}
EXPORT_SYMBOL(drm_helper_resume_force_mode);
 
void drm_kms_helper_hotplug_event(struct drm_device *dev)
{
	/* send a uevent + call fbdev */
    if (dev->mode_config.funcs->output_poll_changed)
		dev->mode_config.funcs->output_poll_changed(dev);
}
EXPORT_SYMBOL(drm_kms_helper_hotplug_event);
 
#define DRM_OUTPUT_POLL_PERIOD (10*HZ)
static void output_poll_execute(struct work_struct *work)
{
	struct delayed_work *delayed_work = to_delayed_work(work);
	struct drm_device *dev = container_of(delayed_work, struct drm_device, mode_config.output_poll_work);
	struct drm_connector *connector;
	enum drm_connector_status old_status;
	bool repoll = false, changed = false;
 
	if (!drm_kms_helper_poll)
		return;
 
	mutex_lock(&dev->mode_config.mutex);
	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
 
		/* Ignore forced connectors. */
		if (connector->force)
			continue;
 
		/* Ignore HPD capable connectors and connectors where we don't
		 * want any hotplug detection at all for polling. */
		if (!connector->polled || connector->polled == DRM_CONNECTOR_POLL_HPD)
			continue;
 
			repoll = true;
 
		old_status = connector->status;
		/* if we are connected and don't want to poll for disconnect
		   skip it */
		if (old_status == connector_status_connected &&
		    !(connector->polled & DRM_CONNECTOR_POLL_DISCONNECT))
			continue;
 
		connector->status = connector->funcs->detect(connector, false);
		if (old_status != connector->status) {
			const char *old, *new;
 
			old = drm_get_connector_status_name(old_status);
			new = drm_get_connector_status_name(connector->status);
 
			DRM_DEBUG_KMS("[CONNECTOR:%d:%s] "
				      "status updated from %s to %s\n",
			      connector->base.id,
			      drm_get_connector_name(connector),
				      old, new);
 
			changed = true;
	}
	}
 
	mutex_unlock(&dev->mode_config.mutex);
 
	if (changed)
		drm_kms_helper_hotplug_event(dev);
 
//   if (repoll)
//       schedule_delayed_work(delayed_work, DRM_OUTPUT_POLL_PERIOD);
}
 
void drm_kms_helper_poll_disable(struct drm_device *dev)
{
	if (!dev->mode_config.poll_enabled)
		return;
//   cancel_delayed_work_sync(&dev->mode_config.output_poll_work);
}
EXPORT_SYMBOL(drm_kms_helper_poll_disable);
 
void drm_kms_helper_poll_enable(struct drm_device *dev)
{
	bool poll = false;
	struct drm_connector *connector;
 
	if (!dev->mode_config.poll_enabled || !drm_kms_helper_poll)
		return;
 
	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
		if (connector->polled & (DRM_CONNECTOR_POLL_CONNECT |
					 DRM_CONNECTOR_POLL_DISCONNECT))
			poll = true;
	}
 
//   if (poll)
//       schedule_delayed_work(&dev->mode_config.output_poll_work, DRM_OUTPUT_POLL_PERIOD);
}
EXPORT_SYMBOL(drm_kms_helper_poll_enable);
 
void drm_kms_helper_poll_init(struct drm_device *dev)
{
	INIT_DELAYED_WORK(&dev->mode_config.output_poll_work, output_poll_execute);
	dev->mode_config.poll_enabled = true;
 
	drm_kms_helper_poll_enable(dev);
}
EXPORT_SYMBOL(drm_kms_helper_poll_init);
 
void drm_kms_helper_poll_fini(struct drm_device *dev)
{
	drm_kms_helper_poll_disable(dev);
}
EXPORT_SYMBOL(drm_kms_helper_poll_fini);
 
void drm_helper_hpd_irq_event(struct drm_device *dev)
{
	struct drm_connector *connector;
	enum drm_connector_status old_status;
	bool changed = false;
 
	if (!dev->mode_config.poll_enabled)
		return;
 
	mutex_lock(&dev->mode_config.mutex);
	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
 
		/* Only handle HPD capable connectors. */
		if (!(connector->polled & DRM_CONNECTOR_POLL_HPD))
			continue;
 
		old_status = connector->status;
 
		connector->status = connector->funcs->detect(connector, false);
		DRM_DEBUG_KMS("[CONNECTOR:%d:%s] status updated from %s to %s\n",
			      connector->base.id,
			      drm_get_connector_name(connector),
			      drm_get_connector_status_name(old_status),
			      drm_get_connector_status_name(connector->status));
		if (old_status != connector->status)
			changed = true;
	}
 
	mutex_unlock(&dev->mode_config.mutex);
 
	if (changed)
		drm_kms_helper_hotplug_event(dev);
}
EXPORT_SYMBOL(drm_helper_hpd_irq_event);

Rev 4075	Rev 4104
1	/*	1	/*
2	* Copyright (c) 2006-2008 Intel Corporation	2	* Copyright (c) 2006-2008 Intel Corporation
3	* Copyright (c) 2007 Dave Airlie	3	* Copyright (c) 2007 Dave Airlie
4	*	4	*
5	* DRM core CRTC related functions	5	* DRM core CRTC related functions
6	*	6	*
7	* Permission to use, copy, modify, distribute, and sell this software and its	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	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	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	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	11	* that the name of the copyright holders not be used in advertising or
12	* publicity pertaining to distribution of the software without specific,	12	* publicity pertaining to distribution of the software without specific,
13	* written prior permission. The copyright holders make no representations	13	* written prior permission. The copyright holders make no representations
14	* about the suitability of this software for any purpose. It is provided "as	14	* about the suitability of this software for any purpose. It is provided "as
15	* is" without express or implied warranty.	15	* is" without express or implied warranty.
16	*	16	*
17	* THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,	17	* THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
18	* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO	18	* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
19	* EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR	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,	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	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	22	* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
23	* OF THIS SOFTWARE.	23	* OF THIS SOFTWARE.
24	*	24	*
25	* Authors:	25	* Authors:
26	* Keith Packard	26	* Keith Packard
27	* Eric Anholt	27	* Eric Anholt
28	* Dave Airlie	28	* Dave Airlie
29	* Jesse Barnes	29	* Jesse Barnes
30	*/	30	*/
31		31
32	#include	32	#include
33	#include	33	#include
34		34
35	#include	35	#include
36	#include	36	#include
37	#include	37	#include
38	#include	38	#include
39	#include	39	#include
40	#include	40	#include
41		41
42	/**	42	/**
43	* drm_helper_move_panel_connectors_to_head() - move panels to the front in the	43	* drm_helper_move_panel_connectors_to_head() - move panels to the front in the
44	* connector list	44	* connector list
45	* @dev: drm device to operate on	45	* @dev: drm device to operate on
46	*	46	*
47	* Some userspace presumes that the first connected connector is the main	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	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	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	50	* (eDP/LVDS) panels to the front of the connector list, instead of
51	* painstakingly trying to initialize them in the right order.	51	* painstakingly trying to initialize them in the right order.
52	*/	52	*/
53	void drm_helper_move_panel_connectors_to_head(struct drm_device *dev)	53	void drm_helper_move_panel_connectors_to_head(struct drm_device *dev)
54	{	54	{
55	struct drm_connector connector, tmp;	55	struct drm_connector connector, tmp;
56	struct list_head panel_list;	56	struct list_head panel_list;
57		57
58	INIT_LIST_HEAD(&panel_list);	58	INIT_LIST_HEAD(&panel_list);
59		59
60	list_for_each_entry_safe(connector, tmp,	60	list_for_each_entry_safe(connector, tmp,
61	&dev->mode_config.connector_list, head) {	61	&dev->mode_config.connector_list, head) {
62	if (connector->connector_type == DRM_MODE_CONNECTOR_LVDS \|\|	62	if (connector->connector_type == DRM_MODE_CONNECTOR_LVDS \|\|
63	connector->connector_type == DRM_MODE_CONNECTOR_eDP)	63	connector->connector_type == DRM_MODE_CONNECTOR_eDP)
64	list_move_tail(&connector->head, &panel_list);	64	list_move_tail(&connector->head, &panel_list);
65	}	65	}
66		66
67	list_splice(&panel_list, &dev->mode_config.connector_list);	67	list_splice(&panel_list, &dev->mode_config.connector_list);
68	}	68	}
69	EXPORT_SYMBOL(drm_helper_move_panel_connectors_to_head);	69	EXPORT_SYMBOL(drm_helper_move_panel_connectors_to_head);
70		70
71	static bool drm_kms_helper_poll = true;	71	static bool drm_kms_helper_poll = true;
72	module_param_named(poll, drm_kms_helper_poll, bool, 0600);	72	module_param_named(poll, drm_kms_helper_poll, bool, 0600);
73		73
74	static void drm_mode_validate_flag(struct drm_connector *connector,	74	static void drm_mode_validate_flag(struct drm_connector *connector,
75	int flags)	75	int flags)
76	{	76	{
77	struct drm_display_mode *mode;	77	struct drm_display_mode *mode;
78		78
79	if (flags == (DRM_MODE_FLAG_DBLSCAN \| DRM_MODE_FLAG_INTERLACE))	79	if (flags == (DRM_MODE_FLAG_DBLSCAN \| DRM_MODE_FLAG_INTERLACE))
80	return;	80	return;
81		81
82	list_for_each_entry(mode, &connector->modes, head) {	82	list_for_each_entry(mode, &connector->modes, head) {
83	if ((mode->flags & DRM_MODE_FLAG_INTERLACE) &&	83	if ((mode->flags & DRM_MODE_FLAG_INTERLACE) &&
84	!(flags & DRM_MODE_FLAG_INTERLACE))	84	!(flags & DRM_MODE_FLAG_INTERLACE))
85	mode->status = MODE_NO_INTERLACE;	85	mode->status = MODE_NO_INTERLACE;
86	if ((mode->flags & DRM_MODE_FLAG_DBLSCAN) &&	86	if ((mode->flags & DRM_MODE_FLAG_DBLSCAN) &&
87	!(flags & DRM_MODE_FLAG_DBLSCAN))	87	!(flags & DRM_MODE_FLAG_DBLSCAN))
88	mode->status = MODE_NO_DBLESCAN;	88	mode->status = MODE_NO_DBLESCAN;
89	}	89	}
90		90
91	return;	91	return;
92	}	92	}
93		93
94	/**	94	/**
95	* drm_helper_probe_single_connector_modes - get complete set of display modes	95	* drm_helper_probe_single_connector_modes - get complete set of display modes
96	* @connector: connector to probe	96	* @connector: connector to probe
97	* @maxX: max width for modes	97	* @maxX: max width for modes
98	* @maxY: max height for modes	98	* @maxY: max height for modes
99	*	99	*
100	* LOCKING:	100	* LOCKING:
101	* Caller must hold mode config lock.	101	* Caller must hold mode config lock.
102	*	102	*
103	* Based on the helper callbacks implemented by @connector try to detect all	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,	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	105	* then culled (based on validity and the @maxX, @maxY parameters) and put into
106	* the normal modes list.	106	* the normal modes list.
107	*	107	*
108	* Intended to be use as a generic implementation of the ->probe() @connector	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	109	* callback for drivers that use the crtc helpers for output mode filtering and
110	* detection.	110	* detection.
111	*	111	*
112	* RETURNS:	112	* RETURNS:
113	* Number of modes found on @connector.	113	* Number of modes found on @connector.
114	*/	114	*/
115	int drm_helper_probe_single_connector_modes(struct drm_connector *connector,	115	int drm_helper_probe_single_connector_modes(struct drm_connector *connector,
116	uint32_t maxX, uint32_t maxY)	116	uint32_t maxX, uint32_t maxY)
117	{	117	{
118	struct drm_device *dev = connector->dev;	118	struct drm_device *dev = connector->dev;
119	struct drm_display_mode *mode;	119	struct drm_display_mode *mode;
120	struct drm_connector_helper_funcs *connector_funcs =	120	struct drm_connector_helper_funcs *connector_funcs =
121	connector->helper_private;	121	connector->helper_private;
122	int count = 0;	122	int count = 0;
123	int mode_flags = 0;	123	int mode_flags = 0;
124	bool verbose_prune = true;	124	bool verbose_prune = true;
125		125
126	DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n", connector->base.id,	126	DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n", connector->base.id,
127	drm_get_connector_name(connector));	127	drm_get_connector_name(connector));
128	/* set all modes to the unverified state */	128	/* set all modes to the unverified state */
129	list_for_each_entry(mode, &connector->modes, head)	129	list_for_each_entry(mode, &connector->modes, head)
130	mode->status = MODE_UNVERIFIED;	130	mode->status = MODE_UNVERIFIED;
131		131
132	if (connector->force) {	132	if (connector->force) {
133	if (connector->force == DRM_FORCE_ON)	133	if (connector->force == DRM_FORCE_ON)
134	connector->status = connector_status_connected;	134	connector->status = connector_status_connected;
135	else	135	else
136	connector->status = connector_status_disconnected;	136	connector->status = connector_status_disconnected;
137	if (connector->funcs->force)	137	if (connector->funcs->force)
138	connector->funcs->force(connector);	138	connector->funcs->force(connector);
139	} else {	139	} else {
140	connector->status = connector->funcs->detect(connector, true);	140	connector->status = connector->funcs->detect(connector, true);
141	}	141	}
142		142
143	/* Re-enable polling in case the global poll config changed. */	143	/* Re-enable polling in case the global poll config changed. */
144	if (drm_kms_helper_poll != dev->mode_config.poll_running)	144	if (drm_kms_helper_poll != dev->mode_config.poll_running)
145	drm_kms_helper_poll_enable(dev);	145	drm_kms_helper_poll_enable(dev);
146		146
147	dev->mode_config.poll_running = drm_kms_helper_poll;	147	dev->mode_config.poll_running = drm_kms_helper_poll;
148		148
149	if (connector->status == connector_status_disconnected) {	149	if (connector->status == connector_status_disconnected) {
150	DRM_DEBUG_KMS("[CONNECTOR:%d:%s] disconnected\n",	150	DRM_DEBUG_KMS("[CONNECTOR:%d:%s] disconnected\n",
151	connector->base.id, drm_get_connector_name(connector));	151	connector->base.id, drm_get_connector_name(connector));
152	drm_mode_connector_update_edid_property(connector, NULL);	152	drm_mode_connector_update_edid_property(connector, NULL);
153	verbose_prune = false;	153	verbose_prune = false;
154	goto prune;	154	goto prune;
155	}	155	}
156		156
157	#ifdef CONFIG_DRM_LOAD_EDID_FIRMWARE	157	#ifdef CONFIG_DRM_LOAD_EDID_FIRMWARE
158	count = drm_load_edid_firmware(connector);	158	count = drm_load_edid_firmware(connector);
159	if (count == 0)	159	if (count == 0)
160	#endif	160	#endif
161	count = (*connector_funcs->get_modes)(connector);	161	count = (*connector_funcs->get_modes)(connector);
162		162
163	if (count == 0 && connector->status == connector_status_connected)	163	if (count == 0 && connector->status == connector_status_connected)
164	count = drm_add_modes_noedid(connector, 1024, 768);	164	count = drm_add_modes_noedid(connector, 1024, 768);
165	if (count == 0)	165	if (count == 0)
166	goto prune;	166	goto prune;
167		167
168	drm_mode_connector_list_update(connector);	168	drm_mode_connector_list_update(connector);
169		169
170	if (maxX && maxY)	170	if (maxX && maxY)
171	drm_mode_validate_size(dev, &connector->modes, maxX,	171	drm_mode_validate_size(dev, &connector->modes, maxX,
172	maxY, 0);	172	maxY, 0);
173		173
174	if (connector->interlace_allowed)	174	if (connector->interlace_allowed)
175	mode_flags \|= DRM_MODE_FLAG_INTERLACE;	175	mode_flags \|= DRM_MODE_FLAG_INTERLACE;
176	if (connector->doublescan_allowed)	176	if (connector->doublescan_allowed)
177	mode_flags \|= DRM_MODE_FLAG_DBLSCAN;	177	mode_flags \|= DRM_MODE_FLAG_DBLSCAN;
178	drm_mode_validate_flag(connector, mode_flags);	178	drm_mode_validate_flag(connector, mode_flags);
179		179
180	list_for_each_entry(mode, &connector->modes, head) {	180	list_for_each_entry(mode, &connector->modes, head) {
181	if (mode->status == MODE_OK)	181	if (mode->status == MODE_OK)
182	mode->status = connector_funcs->mode_valid(connector,	182	mode->status = connector_funcs->mode_valid(connector,
183	mode);	183	mode);
184	}	184	}
185		185
186	prune:	186	prune:
187	drm_mode_prune_invalid(dev, &connector->modes, verbose_prune);	187	drm_mode_prune_invalid(dev, &connector->modes, verbose_prune);
188		188
189	if (list_empty(&connector->modes))	189	if (list_empty(&connector->modes))
190	return 0;	190	return 0;
191		191
192	list_for_each_entry(mode, &connector->modes, head)	192	list_for_each_entry(mode, &connector->modes, head)
193	mode->vrefresh = drm_mode_vrefresh(mode);	193	mode->vrefresh = drm_mode_vrefresh(mode);
194		194
195	drm_mode_sort(&connector->modes);	195	drm_mode_sort(&connector->modes);
196		196
197	DRM_DEBUG_KMS("[CONNECTOR:%d:%s] probed modes :\n", connector->base.id,	197	DRM_DEBUG_KMS("[CONNECTOR:%d:%s] probed modes :\n", connector->base.id,
198	drm_get_connector_name(connector));	198	drm_get_connector_name(connector));
199	list_for_each_entry(mode, &connector->modes, head) {	199	list_for_each_entry(mode, &connector->modes, head) {
200	drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V);	200	drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V);
201	drm_mode_debug_printmodeline(mode);	201	drm_mode_debug_printmodeline(mode);
202	}	202	}
203		203
204	return count;	204	return count;
205	}	205	}
206	EXPORT_SYMBOL(drm_helper_probe_single_connector_modes);	206	EXPORT_SYMBOL(drm_helper_probe_single_connector_modes);
207		207
208	/**	208	/**
209	* drm_helper_encoder_in_use - check if a given encoder is in use	209	* drm_helper_encoder_in_use - check if a given encoder is in use
210	* @encoder: encoder to check	210	* @encoder: encoder to check
211	*	211	*
212	* LOCKING:	212	* LOCKING:
213	* Caller must hold mode config lock.	213	* Caller must hold mode config lock.
214	*	214	*
215	* Walk @encoders's DRM device's mode_config and see if it's in use.	215	* Walk @encoders's DRM device's mode_config and see if it's in use.
216	*	216	*
217	* RETURNS:	217	* RETURNS:
218	* True if @encoder is part of the mode_config, false otherwise.	218	* True if @encoder is part of the mode_config, false otherwise.
219	*/	219	*/
220	bool drm_helper_encoder_in_use(struct drm_encoder *encoder)	220	bool drm_helper_encoder_in_use(struct drm_encoder *encoder)
221	{	221	{
222	struct drm_connector *connector;	222	struct drm_connector *connector;
223	struct drm_device *dev = encoder->dev;	223	struct drm_device *dev = encoder->dev;
224	list_for_each_entry(connector, &dev->mode_config.connector_list, head)	224	list_for_each_entry(connector, &dev->mode_config.connector_list, head)
225	if (connector->encoder == encoder)	225	if (connector->encoder == encoder)
226	return true;	226	return true;
227	return false;	227	return false;
228	}	228	}
229	EXPORT_SYMBOL(drm_helper_encoder_in_use);	229	EXPORT_SYMBOL(drm_helper_encoder_in_use);
230		230
231	/**	231	/**
232	* drm_helper_crtc_in_use - check if a given CRTC is in a mode_config	232	* drm_helper_crtc_in_use - check if a given CRTC is in a mode_config
233	* @crtc: CRTC to check	233	* @crtc: CRTC to check
234	*	234	*
235	* LOCKING:	235	* LOCKING:
236	* Caller must hold mode config lock.	236	* Caller must hold mode config lock.
237	*	237	*
238	* Walk @crtc's DRM device's mode_config and see if it's in use.	238	* Walk @crtc's DRM device's mode_config and see if it's in use.
239	*	239	*
240	* RETURNS:	240	* RETURNS:
241	* True if @crtc is part of the mode_config, false otherwise.	241	* True if @crtc is part of the mode_config, false otherwise.
242	*/	242	*/
243	bool drm_helper_crtc_in_use(struct drm_crtc *crtc)	243	bool drm_helper_crtc_in_use(struct drm_crtc *crtc)
244	{	244	{
245	struct drm_encoder *encoder;	245	struct drm_encoder *encoder;
246	struct drm_device *dev = crtc->dev;	246	struct drm_device *dev = crtc->dev;
247	/* FIXME: Locking around list access? */	247	/* FIXME: Locking around list access? */
248	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head)	248	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head)
249	if (encoder->crtc == crtc && drm_helper_encoder_in_use(encoder))	249	if (encoder->crtc == crtc && drm_helper_encoder_in_use(encoder))
250	return true;	250	return true;
251	return false;	251	return false;
252	}	252	}
253	EXPORT_SYMBOL(drm_helper_crtc_in_use);	253	EXPORT_SYMBOL(drm_helper_crtc_in_use);
254		254
255	static void	255	static void
256	drm_encoder_disable(struct drm_encoder *encoder)	256	drm_encoder_disable(struct drm_encoder *encoder)
257	{	257	{
258	struct drm_encoder_helper_funcs *encoder_funcs = encoder->helper_private;	258	struct drm_encoder_helper_funcs *encoder_funcs = encoder->helper_private;
-		259
-		260	if (encoder->bridge)
-		261	encoder->bridge->funcs->disable(encoder->bridge);
259		262
260	if (encoder_funcs->disable)	263	if (encoder_funcs->disable)
261	(*encoder_funcs->disable)(encoder);	264	(*encoder_funcs->disable)(encoder);
262	else	265	else
263	(*encoder_funcs->dpms)(encoder, DRM_MODE_DPMS_OFF);	266	(*encoder_funcs->dpms)(encoder, DRM_MODE_DPMS_OFF);
-		267
-		268	if (encoder->bridge)
-		269	encoder->bridge->funcs->post_disable(encoder->bridge);
264	}	270	}
265		271
266	/**	272	/**
267	* drm_helper_disable_unused_functions - disable unused objects	273	* drm_helper_disable_unused_functions - disable unused objects
268	* @dev: DRM device	274	* @dev: DRM device
269	*	275	*
270	* LOCKING:	276	* LOCKING:
271	* Caller must hold mode config lock.	277	* Caller must hold mode config lock.
272	*	278	*
273	* If an connector or CRTC isn't part of @dev's mode_config, it can be disabled	279	* If an connector or CRTC isn't part of @dev's mode_config, it can be disabled
274	* by calling its dpms function, which should power it off.	280	* by calling its dpms function, which should power it off.
275	*/	281	*/
276	void drm_helper_disable_unused_functions(struct drm_device *dev)	282	void drm_helper_disable_unused_functions(struct drm_device *dev)
277	{	283	{
278	struct drm_encoder *encoder;	284	struct drm_encoder *encoder;
279	struct drm_connector *connector;	285	struct drm_connector *connector;
280	struct drm_crtc *crtc;	286	struct drm_crtc *crtc;
281		287
282	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {	288	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
283	if (!connector->encoder)	289	if (!connector->encoder)
284	continue;	290	continue;
285	if (connector->status == connector_status_disconnected)	291	if (connector->status == connector_status_disconnected)
286	connector->encoder = NULL;	292	connector->encoder = NULL;
287	}	293	}
288		294
289	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {	295	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
290	if (!drm_helper_encoder_in_use(encoder)) {	296	if (!drm_helper_encoder_in_use(encoder)) {
291	drm_encoder_disable(encoder);	297	drm_encoder_disable(encoder);
292	/* disconnector encoder from any connector */	298	/* disconnector encoder from any connector */
293	encoder->crtc = NULL;	299	encoder->crtc = NULL;
294	}	300	}
295	}	301	}
296		302
297	list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {	303	list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
298	struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;	304	struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
299	crtc->enabled = drm_helper_crtc_in_use(crtc);	305	crtc->enabled = drm_helper_crtc_in_use(crtc);
300	if (!crtc->enabled) {	306	if (!crtc->enabled) {
301	if (crtc_funcs->disable)	307	if (crtc_funcs->disable)
302	(*crtc_funcs->disable)(crtc);	308	(*crtc_funcs->disable)(crtc);
303	else	309	else
304	(*crtc_funcs->dpms)(crtc, DRM_MODE_DPMS_OFF);	310	(*crtc_funcs->dpms)(crtc, DRM_MODE_DPMS_OFF);
305	crtc->fb = NULL;	311	crtc->fb = NULL;
306	}	312	}
307	}	313	}
308	}	314	}
309	EXPORT_SYMBOL(drm_helper_disable_unused_functions);	315	EXPORT_SYMBOL(drm_helper_disable_unused_functions);
310		316
311	/**	317	/**
312	* drm_encoder_crtc_ok - can a given crtc drive a given encoder?	318	* drm_encoder_crtc_ok - can a given crtc drive a given encoder?
313	* @encoder: encoder to test	319	* @encoder: encoder to test
314	* @crtc: crtc to test	320	* @crtc: crtc to test
315	*	321	*
316	* Return false if @encoder can't be driven by @crtc, true otherwise.	322	* Return false if @encoder can't be driven by @crtc, true otherwise.
317	*/	323	*/
318	static bool drm_encoder_crtc_ok(struct drm_encoder *encoder,	324	static bool drm_encoder_crtc_ok(struct drm_encoder *encoder,
319	struct drm_crtc *crtc)	325	struct drm_crtc *crtc)
320	{	326	{
321	struct drm_device *dev;	327	struct drm_device *dev;
322	struct drm_crtc *tmp;	328	struct drm_crtc *tmp;
323	int crtc_mask = 1;	329	int crtc_mask = 1;
324		330
325	WARN(!crtc, "checking null crtc?\n");	331	WARN(!crtc, "checking null crtc?\n");
326		332
327	dev = crtc->dev;	333	dev = crtc->dev;
328		334
329	list_for_each_entry(tmp, &dev->mode_config.crtc_list, head) {	335	list_for_each_entry(tmp, &dev->mode_config.crtc_list, head) {
330	if (tmp == crtc)	336	if (tmp == crtc)
331	break;	337	break;
332	crtc_mask <<= 1;	338	crtc_mask <<= 1;
333	}	339	}
334		340
335	if (encoder->possible_crtcs & crtc_mask)	341	if (encoder->possible_crtcs & crtc_mask)
336	return true;	342	return true;
337	return false;	343	return false;
338	}	344	}
339		345
340	/*	346	/*
341	* Check the CRTC we're going to map each output to vs. its current	347	* Check the CRTC we're going to map each output to vs. its current
342	* CRTC. If they don't match, we have to disable the output and the CRTC	348	* CRTC. If they don't match, we have to disable the output and the CRTC
343	* since the driver will have to re-route things.	349	* since the driver will have to re-route things.
344	*/	350	*/
345	static void	351	static void
346	drm_crtc_prepare_encoders(struct drm_device *dev)	352	drm_crtc_prepare_encoders(struct drm_device *dev)
347	{	353	{
348	struct drm_encoder_helper_funcs *encoder_funcs;	354	struct drm_encoder_helper_funcs *encoder_funcs;
349	struct drm_encoder *encoder;	355	struct drm_encoder *encoder;
350		356
351	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {	357	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
352	encoder_funcs = encoder->helper_private;	358	encoder_funcs = encoder->helper_private;
353	/* Disable unused encoders */	359	/* Disable unused encoders */
354	if (encoder->crtc == NULL)	360	if (encoder->crtc == NULL)
355	drm_encoder_disable(encoder);	361	drm_encoder_disable(encoder);
356	/* Disable encoders whose CRTC is about to change */	362	/* Disable encoders whose CRTC is about to change */
357	if (encoder_funcs->get_crtc &&	363	if (encoder_funcs->get_crtc &&
358	encoder->crtc != (*encoder_funcs->get_crtc)(encoder))	364	encoder->crtc != (*encoder_funcs->get_crtc)(encoder))
359	drm_encoder_disable(encoder);	365	drm_encoder_disable(encoder);
360	}	366	}
361	}	367	}
362		368
363	/**	369	/**
364	* drm_crtc_helper_set_mode - internal helper to set a mode	370	* drm_crtc_helper_set_mode - internal helper to set a mode
365	* @crtc: CRTC to program	371	* @crtc: CRTC to program
366	* @mode: mode to use	372	* @mode: mode to use
367	* @x: horizontal offset into the surface	373	* @x: horizontal offset into the surface
368	* @y: vertical offset into the surface	374	* @y: vertical offset into the surface
369	* @old_fb: old framebuffer, for cleanup	375	* @old_fb: old framebuffer, for cleanup
370	*	376	*
371	* LOCKING:	377	* LOCKING:
372	* Caller must hold mode config lock.	378	* Caller must hold mode config lock.
373	*	379	*
374	* Try to set @mode on @crtc. Give @crtc and its associated connectors a chance	380	* Try to set @mode on @crtc. Give @crtc and its associated connectors a chance
375	* to fixup or reject the mode prior to trying to set it. This is an internal	381	* to fixup or reject the mode prior to trying to set it. This is an internal
376	* helper that drivers could e.g. use to update properties that require the	382	* helper that drivers could e.g. use to update properties that require the
377	* entire output pipe to be disabled and re-enabled in a new configuration. For	383	* entire output pipe to be disabled and re-enabled in a new configuration. For
378	* example for changing whether audio is enabled on a hdmi link or for changing	384	* example for changing whether audio is enabled on a hdmi link or for changing
379	* panel fitter or dither attributes. It is also called by the	385	* panel fitter or dither attributes. It is also called by the
380	* drm_crtc_helper_set_config() helper function to drive the mode setting	386	* drm_crtc_helper_set_config() helper function to drive the mode setting
381	* sequence.	387	* sequence.
382	*	388	*
383	* RETURNS:	389	* RETURNS:
384	* True if the mode was set successfully, or false otherwise.	390	* True if the mode was set successfully, or false otherwise.
385	*/	391	*/
386	bool drm_crtc_helper_set_mode(struct drm_crtc *crtc,	392	bool drm_crtc_helper_set_mode(struct drm_crtc *crtc,
387	struct drm_display_mode *mode,	393	struct drm_display_mode *mode,
388	int x, int y,	394	int x, int y,
389	struct drm_framebuffer *old_fb)	395	struct drm_framebuffer *old_fb)
390	{	396	{
391	struct drm_device *dev = crtc->dev;	397	struct drm_device *dev = crtc->dev;
392	struct drm_display_mode *adjusted_mode, saved_mode, saved_hwmode;	398	struct drm_display_mode *adjusted_mode, saved_mode, saved_hwmode;
393	struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;	399	struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
394	struct drm_encoder_helper_funcs *encoder_funcs;	400	struct drm_encoder_helper_funcs *encoder_funcs;
395	int saved_x, saved_y;	401	int saved_x, saved_y;
396	struct drm_encoder *encoder;	402	struct drm_encoder *encoder;
397	bool ret = true;	403	bool ret = true;
398		404
399	crtc->enabled = drm_helper_crtc_in_use(crtc);	405	crtc->enabled = drm_helper_crtc_in_use(crtc);
400	if (!crtc->enabled)	406	if (!crtc->enabled)
401	return true;	407	return true;
402		408
403	adjusted_mode = drm_mode_duplicate(dev, mode);	409	adjusted_mode = drm_mode_duplicate(dev, mode);
404	if (!adjusted_mode)	410	if (!adjusted_mode)
405	return false;	411	return false;
406		412
407	saved_hwmode = crtc->hwmode;	413	saved_hwmode = crtc->hwmode;
408	saved_mode = crtc->mode;	414	saved_mode = crtc->mode;
409	saved_x = crtc->x;	415	saved_x = crtc->x;
410	saved_y = crtc->y;	416	saved_y = crtc->y;
411		417
412	/* Update crtc values up front so the driver can rely on them for mode	418	/* Update crtc values up front so the driver can rely on them for mode
413	* setting.	419	* setting.
414	*/	420	*/
415	crtc->mode = *mode;	421	crtc->mode = *mode;
416	crtc->x = x;	422	crtc->x = x;
417	crtc->y = y;	423	crtc->y = y;
418		424
419	/* Pass our mode to the connectors and the CRTC to give them a chance to	425	/* Pass our mode to the connectors and the CRTC to give them a chance to
420	* adjust it according to limitations or connector properties, and also	426	* adjust it according to limitations or connector properties, and also
421	* a chance to reject the mode entirely.	427	* a chance to reject the mode entirely.
422	*/	428	*/
423	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {	429	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
424		430
425	if (encoder->crtc != crtc)	431	if (encoder->crtc != crtc)
426	continue;	432	continue;
-		433
-		434	if (encoder->bridge && encoder->bridge->funcs->mode_fixup) {
-		435	ret = encoder->bridge->funcs->mode_fixup(
-		436	encoder->bridge, mode, adjusted_mode);
-		437	if (!ret) {
-		438	DRM_DEBUG_KMS("Bridge fixup failed\n");
-		439	goto done;
-		440	}
-		441	}
-		442
427	encoder_funcs = encoder->helper_private;	443	encoder_funcs = encoder->helper_private;
428	if (!(ret = encoder_funcs->mode_fixup(encoder, mode,	444	if (!(ret = encoder_funcs->mode_fixup(encoder, mode,
429	adjusted_mode))) {	445	adjusted_mode))) {
430	DRM_DEBUG_KMS("Encoder fixup failed\n");	446	DRM_DEBUG_KMS("Encoder fixup failed\n");
431	goto done;	447	goto done;
432	}	448	}
433	}	449	}
434		450
435	if (!(ret = crtc_funcs->mode_fixup(crtc, mode, adjusted_mode))) {	451	if (!(ret = crtc_funcs->mode_fixup(crtc, mode, adjusted_mode))) {
436	DRM_DEBUG_KMS("CRTC fixup failed\n");	452	DRM_DEBUG_KMS("CRTC fixup failed\n");
437	goto done;	453	goto done;
438	}	454	}
439	DRM_DEBUG_KMS("[CRTC:%d]\n", crtc->base.id);	455	DRM_DEBUG_KMS("[CRTC:%d]\n", crtc->base.id);
440		456
441	/* Prepare the encoders and CRTCs before setting the mode. */	457	/* Prepare the encoders and CRTCs before setting the mode. */
442	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {	458	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
443		459
444	if (encoder->crtc != crtc)	460	if (encoder->crtc != crtc)
445	continue;	461	continue;
-		462
-		463	if (encoder->bridge)
-		464	encoder->bridge->funcs->disable(encoder->bridge);
-		465
446	encoder_funcs = encoder->helper_private;	466	encoder_funcs = encoder->helper_private;
447	/* Disable the encoders as the first thing we do. */	467	/* Disable the encoders as the first thing we do. */
448	encoder_funcs->prepare(encoder);	468	encoder_funcs->prepare(encoder);
-		469
-		470	if (encoder->bridge)
-		471	encoder->bridge->funcs->post_disable(encoder->bridge);
449	}	472	}
450		473
451	drm_crtc_prepare_encoders(dev);	474	drm_crtc_prepare_encoders(dev);
452		475
453	crtc_funcs->prepare(crtc);	476	crtc_funcs->prepare(crtc);
454		477
455	/* Set up the DPLL and any encoders state that needs to adjust or depend	478	/* Set up the DPLL and any encoders state that needs to adjust or depend
456	* on the DPLL.	479	* on the DPLL.
457	*/	480	*/
458	ret = !crtc_funcs->mode_set(crtc, mode, adjusted_mode, x, y, old_fb);	481	ret = !crtc_funcs->mode_set(crtc, mode, adjusted_mode, x, y, old_fb);
459	if (!ret)	482	if (!ret)
460	goto done;	483	goto done;
461		484
462	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {	485	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
463		486
464	if (encoder->crtc != crtc)	487	if (encoder->crtc != crtc)
465	continue;	488	continue;
466		489
467	DRM_DEBUG_KMS("[ENCODER:%d:%s] set [MODE:%d:%s]\n",	490	DRM_DEBUG_KMS("[ENCODER:%d:%s] set [MODE:%d:%s]\n",
468	encoder->base.id, drm_get_encoder_name(encoder),	491	encoder->base.id, drm_get_encoder_name(encoder),
469	mode->base.id, mode->name);	492	mode->base.id, mode->name);
470	encoder_funcs = encoder->helper_private;	493	encoder_funcs = encoder->helper_private;
471	encoder_funcs->mode_set(encoder, mode, adjusted_mode);	494	encoder_funcs->mode_set(encoder, mode, adjusted_mode);
-		495
-		496	if (encoder->bridge && encoder->bridge->funcs->mode_set)
-		497	encoder->bridge->funcs->mode_set(encoder->bridge, mode,
-		498	adjusted_mode);
472	}	499	}
473		500

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/drm_crtc_helper.c – Rev 4075 → 4104