[linux-2.6-block.git] / drivers / gpu / drm / drm_mode_config.c

/*
 * Copyright (c) 2016 Intel Corporation
 *
 * 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.
 */

#include <drm/drm_encoder.h>
#include <drm/drm_mode_config.h>
#include <drm/drmP.h>

#include "drm_crtc_internal.h"
#include "drm_internal.h"

int drm_modeset_register_all(struct drm_device *dev)
{
	int ret;

	ret = drm_plane_register_all(dev);
	if (ret)
		goto err_plane;

	ret = drm_crtc_register_all(dev);
	if  (ret)
		goto err_crtc;

	ret = drm_encoder_register_all(dev);
	if (ret)
		goto err_encoder;

	ret = drm_connector_register_all(dev);
	if (ret)
		goto err_connector;

	return 0;

err_connector:
	drm_encoder_unregister_all(dev);
err_encoder:
	drm_crtc_unregister_all(dev);
err_crtc:
	drm_plane_unregister_all(dev);
err_plane:
	return ret;
}

void drm_modeset_unregister_all(struct drm_device *dev)
{
	drm_connector_unregister_all(dev);
	drm_encoder_unregister_all(dev);
	drm_crtc_unregister_all(dev);
	drm_plane_unregister_all(dev);
}

/**
 * drm_mode_getresources - get graphics configuration
 * @dev: drm device for the ioctl
 * @data: data pointer for the ioctl
 * @file_priv: drm file for the ioctl call
 *
 * Construct a set of configuration description structures and return
 * them to the user, including CRTC, connector and framebuffer configuration.
 *
 * Called by the user via ioctl.
 *
 * Returns:
 * Zero on success, negative errno on failure.
 */
int drm_mode_getresources(struct drm_device *dev, void *data,
			  struct drm_file *file_priv)
{
	struct drm_mode_card_res *card_res = data;
	struct drm_framebuffer *fb;
	struct drm_connector *connector;
	struct drm_crtc *crtc;
	struct drm_encoder *encoder;
	int count, ret = 0;
	uint32_t __user *fb_id;
	uint32_t __user *crtc_id;
	uint32_t __user *connector_id;
	uint32_t __user *encoder_id;
	struct drm_connector_list_iter conn_iter;

	if (!drm_core_check_feature(dev, DRIVER_MODESET))
		return -EINVAL;


	mutex_lock(&file_priv->fbs_lock);
	count = 0;
	fb_id = u64_to_user_ptr(card_res->fb_id_ptr);
	list_for_each_entry(fb, &file_priv->fbs, filp_head) {
		if (count < card_res->count_fbs &&
		    put_user(fb->base.id, fb_id + count)) {
			mutex_unlock(&file_priv->fbs_lock);
			return -EFAULT;
		}
		count++;
	}
	card_res->count_fbs = count;
	mutex_unlock(&file_priv->fbs_lock);

	card_res->max_height = dev->mode_config.max_height;
	card_res->min_height = dev->mode_config.min_height;
	card_res->max_width = dev->mode_config.max_width;
	card_res->min_width = dev->mode_config.min_width;

	count = 0;
	crtc_id = u64_to_user_ptr(card_res->crtc_id_ptr);
	drm_for_each_crtc(crtc, dev) {
		if (drm_lease_held(file_priv, crtc->base.id)) {
			if (count < card_res->count_crtcs &&
			    put_user(crtc->base.id, crtc_id + count))
				return -EFAULT;
			count++;
		}
	}
	card_res->count_crtcs = count;

	count = 0;
	encoder_id = u64_to_user_ptr(card_res->encoder_id_ptr);
	drm_for_each_encoder(encoder, dev) {
		if (count < card_res->count_encoders &&
		    put_user(encoder->base.id, encoder_id + count))
			return -EFAULT;
		count++;
	}
	card_res->count_encoders = count;

	drm_connector_list_iter_begin(dev, &conn_iter);
	count = 0;
	connector_id = u64_to_user_ptr(card_res->connector_id_ptr);
	drm_for_each_connector_iter(connector, &conn_iter) {
		if (drm_lease_held(file_priv, connector->base.id)) {
			if (count < card_res->count_connectors &&
			    put_user(connector->base.id, connector_id + count)) {
				drm_connector_list_iter_end(&conn_iter);
				return -EFAULT;
			}
			count++;
		}
	}
	card_res->count_connectors = count;
	drm_connector_list_iter_end(&conn_iter);

	return ret;
}

/**
 * drm_mode_config_reset - call ->reset callbacks
 * @dev: drm device
 *
 * This functions calls all the crtc's, encoder's and connector's ->reset
 * callback. Drivers can use this in e.g. their driver load or resume code to
 * reset hardware and software state.
 */
void drm_mode_config_reset(struct drm_device *dev)
{
	struct drm_crtc *crtc;
	struct drm_plane *plane;
	struct drm_encoder *encoder;
	struct drm_connector *connector;
	struct drm_connector_list_iter conn_iter;

	drm_for_each_plane(plane, dev)
		if (plane->funcs->reset)
			plane->funcs->reset(plane);

	drm_for_each_crtc(crtc, dev)
		if (crtc->funcs->reset)
			crtc->funcs->reset(crtc);

	drm_for_each_encoder(encoder, dev)
		if (encoder->funcs->reset)
			encoder->funcs->reset(encoder);

	drm_connector_list_iter_begin(dev, &conn_iter);
	drm_for_each_connector_iter(connector, &conn_iter)
		if (connector->funcs->reset)
			connector->funcs->reset(connector);
	drm_connector_list_iter_end(&conn_iter);
}
EXPORT_SYMBOL(drm_mode_config_reset);

/*
 * Global properties
 */
static const struct drm_prop_enum_list drm_plane_type_enum_list[] = {
	{ DRM_PLANE_TYPE_OVERLAY, "Overlay" },
	{ DRM_PLANE_TYPE_PRIMARY, "Primary" },
	{ DRM_PLANE_TYPE_CURSOR, "Cursor" },
};

static int drm_mode_create_standard_properties(struct drm_device *dev)
{
	struct drm_property *prop;
	int ret;

	ret = drm_connector_create_standard_properties(dev);
	if (ret)
		return ret;

	prop = drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE,
					"type", drm_plane_type_enum_list,
					ARRAY_SIZE(drm_plane_type_enum_list));
	if (!prop)
		return -ENOMEM;
	dev->mode_config.plane_type_property = prop;

	prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
			"SRC_X", 0, UINT_MAX);
	if (!prop)
		return -ENOMEM;
	dev->mode_config.prop_src_x = prop;

	prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
			"SRC_Y", 0, UINT_MAX);
	if (!prop)
		return -ENOMEM;
	dev->mode_config.prop_src_y = prop;

	prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
			"SRC_W", 0, UINT_MAX);
	if (!prop)
		return -ENOMEM;
	dev->mode_config.prop_src_w = prop;

	prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
			"SRC_H", 0, UINT_MAX);
	if (!prop)
		return -ENOMEM;
	dev->mode_config.prop_src_h = prop;

	prop = drm_property_create_signed_range(dev, DRM_MODE_PROP_ATOMIC,
			"CRTC_X", INT_MIN, INT_MAX);
	if (!prop)
		return -ENOMEM;
	dev->mode_config.prop_crtc_x = prop;

	prop = drm_property_create_signed_range(dev, DRM_MODE_PROP_ATOMIC,
			"CRTC_Y", INT_MIN, INT_MAX);
	if (!prop)
		return -ENOMEM;
	dev->mode_config.prop_crtc_y = prop;

	prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
			"CRTC_W", 0, INT_MAX);
	if (!prop)
		return -ENOMEM;
	dev->mode_config.prop_crtc_w = prop;

	prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
			"CRTC_H", 0, INT_MAX);
	if (!prop)
		return -ENOMEM;
	dev->mode_config.prop_crtc_h = prop;

	prop = drm_property_create_object(dev, DRM_MODE_PROP_ATOMIC,
			"FB_ID", DRM_MODE_OBJECT_FB);
	if (!prop)
		return -ENOMEM;
	dev->mode_config.prop_fb_id = prop;

	prop = drm_property_create_signed_range(dev, DRM_MODE_PROP_ATOMIC,
			"IN_FENCE_FD", -1, INT_MAX);
	if (!prop)
		return -ENOMEM;
	dev->mode_config.prop_in_fence_fd = prop;

	prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
			"OUT_FENCE_PTR", 0, U64_MAX);
	if (!prop)
		return -ENOMEM;
	dev->mode_config.prop_out_fence_ptr = prop;

	prop = drm_property_create_object(dev, DRM_MODE_PROP_ATOMIC,
			"CRTC_ID", DRM_MODE_OBJECT_CRTC);
	if (!prop)
		return -ENOMEM;
	dev->mode_config.prop_crtc_id = prop;

	prop = drm_property_create_bool(dev, DRM_MODE_PROP_ATOMIC,
			"ACTIVE");
	if (!prop)
		return -ENOMEM;
	dev->mode_config.prop_active = prop;

	prop = drm_property_create(dev,
			DRM_MODE_PROP_ATOMIC | DRM_MODE_PROP_BLOB,
			"MODE_ID", 0);
	if (!prop)
		return -ENOMEM;
	dev->mode_config.prop_mode_id = prop;

	prop = drm_property_create(dev,
			DRM_MODE_PROP_BLOB,
			"DEGAMMA_LUT", 0);
	if (!prop)
		return -ENOMEM;
	dev->mode_config.degamma_lut_property = prop;

	prop = drm_property_create_range(dev,
			DRM_MODE_PROP_IMMUTABLE,
			"DEGAMMA_LUT_SIZE", 0, UINT_MAX);
	if (!prop)
		return -ENOMEM;
	dev->mode_config.degamma_lut_size_property = prop;

	prop = drm_property_create(dev,
			DRM_MODE_PROP_BLOB,
			"CTM", 0);
	if (!prop)
		return -ENOMEM;
	dev->mode_config.ctm_property = prop;

	prop = drm_property_create(dev,
			DRM_MODE_PROP_BLOB,
			"GAMMA_LUT", 0);
	if (!prop)
		return -ENOMEM;
	dev->mode_config.gamma_lut_property = prop;

	prop = drm_property_create_range(dev,
			DRM_MODE_PROP_IMMUTABLE,
			"GAMMA_LUT_SIZE", 0, UINT_MAX);
	if (!prop)
		return -ENOMEM;
	dev->mode_config.gamma_lut_size_property = prop;

	prop = drm_property_create(dev,
				   DRM_MODE_PROP_IMMUTABLE | DRM_MODE_PROP_BLOB,
				   "IN_FORMATS", 0);
	if (!prop)
		return -ENOMEM;
	dev->mode_config.modifiers_property = prop;

	return 0;
}

/**
 * drm_mode_config_init - initialize DRM mode_configuration structure
 * @dev: DRM device
 *
 * Initialize @dev's mode_config structure, used for tracking the graphics
 * configuration of @dev.
 *
 * Since this initializes the modeset locks, no locking is possible. Which is no
 * problem, since this should happen single threaded at init time. It is the
 * driver's problem to ensure this guarantee.
 *
 */
void drm_mode_config_init(struct drm_device *dev)
{
	mutex_init(&dev->mode_config.mutex);
	drm_modeset_lock_init(&dev->mode_config.connection_mutex);
	mutex_init(&dev->mode_config.idr_mutex);
	mutex_init(&dev->mode_config.fb_lock);
	mutex_init(&dev->mode_config.blob_lock);
	INIT_LIST_HEAD(&dev->mode_config.fb_list);
	INIT_LIST_HEAD(&dev->mode_config.crtc_list);
	INIT_LIST_HEAD(&dev->mode_config.connector_list);
	INIT_LIST_HEAD(&dev->mode_config.encoder_list);
	INIT_LIST_HEAD(&dev->mode_config.property_list);
	INIT_LIST_HEAD(&dev->mode_config.property_blob_list);
	INIT_LIST_HEAD(&dev->mode_config.plane_list);
	idr_init(&dev->mode_config.crtc_idr);
	idr_init(&dev->mode_config.tile_idr);
	ida_init(&dev->mode_config.connector_ida);
	spin_lock_init(&dev->mode_config.connector_list_lock);

	drm_mode_create_standard_properties(dev);

	/* Just to be sure */
	dev->mode_config.num_fb = 0;
	dev->mode_config.num_connector = 0;
	dev->mode_config.num_crtc = 0;
	dev->mode_config.num_encoder = 0;
	dev->mode_config.num_total_plane = 0;
}
EXPORT_SYMBOL(drm_mode_config_init);

/**
 * drm_mode_config_cleanup - free up DRM mode_config info
 * @dev: DRM device
 *
 * Free up all the connectors and CRTCs associated with this DRM device, then
 * free up the framebuffers and associated buffer objects.
 *
 * Note that since this /should/ happen single-threaded at driver/device
 * teardown time, no locking is required. It's the driver's job to ensure that
 * this guarantee actually holds true.
 *
 * FIXME: cleanup any dangling user buffer objects too
 */
void drm_mode_config_cleanup(struct drm_device *dev)
{
	struct drm_connector *connector;
	struct drm_connector_list_iter conn_iter;
	struct drm_crtc *crtc, *ct;
	struct drm_encoder *encoder, *enct;
	struct drm_framebuffer *fb, *fbt;
	struct drm_property *property, *pt;
	struct drm_property_blob *blob, *bt;
	struct drm_plane *plane, *plt;

	list_for_each_entry_safe(encoder, enct, &dev->mode_config.encoder_list,
				 head) {
		encoder->funcs->destroy(encoder);
	}

	drm_connector_list_iter_begin(dev, &conn_iter);
	drm_for_each_connector_iter(connector, &conn_iter) {
		/* drm_connector_list_iter holds an full reference to the
		 * current connector itself, which means it is inherently safe
		 * against unreferencing the current connector - but not against
		 * deleting it right away. */
		drm_connector_put(connector);
	}
	drm_connector_list_iter_end(&conn_iter);
	if (WARN_ON(!list_empty(&dev->mode_config.connector_list))) {
		drm_connector_list_iter_begin(dev, &conn_iter);
		drm_for_each_connector_iter(connector, &conn_iter)
			DRM_ERROR("connector %s leaked!\n", connector->name);
		drm_connector_list_iter_end(&conn_iter);
	}

	list_for_each_entry_safe(property, pt, &dev->mode_config.property_list,
				 head) {
		drm_property_destroy(dev, property);
	}

	list_for_each_entry_safe(plane, plt, &dev->mode_config.plane_list,
				 head) {
		plane->funcs->destroy(plane);
	}

	list_for_each_entry_safe(crtc, ct, &dev->mode_config.crtc_list, head) {
		crtc->funcs->destroy(crtc);
	}

	list_for_each_entry_safe(blob, bt, &dev->mode_config.property_blob_list,
				 head_global) {
		drm_property_blob_put(blob);
	}

	/*
	 * Single-threaded teardown context, so it's not required to grab the
	 * fb_lock to protect against concurrent fb_list access. Contrary, it
	 * would actually deadlock with the drm_framebuffer_cleanup function.
	 *
	 * Also, if there are any framebuffers left, that's a driver leak now,
	 * so politely WARN about this.
	 */
	WARN_ON(!list_empty(&dev->mode_config.fb_list));
	list_for_each_entry_safe(fb, fbt, &dev->mode_config.fb_list, head) {
		drm_framebuffer_free(&fb->base.refcount);
	}

	ida_destroy(&dev->mode_config.connector_ida);
	idr_destroy(&dev->mode_config.tile_idr);
	idr_destroy(&dev->mode_config.crtc_idr);
	drm_modeset_lock_fini(&dev->mode_config.connection_mutex);
}
EXPORT_SYMBOL(drm_mode_config_cleanup);
Commit	Line	Data
28575f16 DV	1	/*
	2	* Copyright (c) 2016 Intel Corporation
	3	*
	4	* Permission to use, copy, modify, distribute, and sell this software and its
	5	* documentation for any purpose is hereby granted without fee, provided that
	6	* the above copyright notice appear in all copies and that both that copyright
	7	* notice and this permission notice appear in supporting documentation, and
	8	* that the name of the copyright holders not be used in advertising or
	9	* publicity pertaining to distribution of the software without specific,
	10	* written prior permission. The copyright holders make no representations
	11	* about the suitability of this software for any purpose. It is provided "as
	12	* is" without express or implied warranty.
	13	*
	14	* THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
	15	* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
	16	* EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
	17	* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
	18	* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
	19	* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
	20	* OF THIS SOFTWARE.
	21	*/
	22
9338203c	23	#include <drm/drm_encoder.h>
28575f16 DV	24	#include <drm/drm_mode_config.h>
	25	#include <drm/drmP.h>
	26
	27	#include "drm_crtc_internal.h"
	28	#include "drm_internal.h"
	29
	30	int drm_modeset_register_all(struct drm_device *dev)
	31	{
	32	int ret;
	33
	34	ret = drm_plane_register_all(dev);
	35	if (ret)
	36	goto err_plane;
	37
	38	ret = drm_crtc_register_all(dev);
	39	if (ret)
	40	goto err_crtc;
	41
	42	ret = drm_encoder_register_all(dev);
	43	if (ret)
	44	goto err_encoder;
	45
	46	ret = drm_connector_register_all(dev);
	47	if (ret)
	48	goto err_connector;
	49
	50	return 0;
	51
	52	err_connector:
	53	drm_encoder_unregister_all(dev);
	54	err_encoder:
	55	drm_crtc_unregister_all(dev);
	56	err_crtc:
	57	drm_plane_unregister_all(dev);
	58	err_plane:
	59	return ret;
	60	}
	61
	62	void drm_modeset_unregister_all(struct drm_device *dev)
	63	{
	64	drm_connector_unregister_all(dev);
	65	drm_encoder_unregister_all(dev);
	66	drm_crtc_unregister_all(dev);
	67	drm_plane_unregister_all(dev);
	68	}
	69
	70	/**
	71	* drm_mode_getresources - get graphics configuration
	72	* @dev: drm device for the ioctl
	73	* @data: data pointer for the ioctl
	74	* @file_priv: drm file for the ioctl call
	75	*
	76	* Construct a set of configuration description structures and return
	77	* them to the user, including CRTC, connector and framebuffer configuration.
	78	*
	79	* Called by the user via ioctl.
	80	*
	81	* Returns:
	82	* Zero on success, negative errno on failure.
	83	*/
	84	int drm_mode_getresources(struct drm_device dev, void data,
	85	struct drm_file *file_priv)
	86	{
	87	struct drm_mode_card_res *card_res = data;
28575f16 DV	88	struct drm_framebuffer *fb;
	89	struct drm_connector *connector;
	90	struct drm_crtc *crtc;
	91	struct drm_encoder *encoder;
697cc9c8	92	int count, ret = 0;
28575f16 DV	93	uint32_t __user *fb_id;
	94	uint32_t __user *crtc_id;
	95	uint32_t __user *connector_id;
	96	uint32_t __user *encoder_id;
613051da	97	struct drm_connector_list_iter conn_iter;
28575f16 DV	98
	99	if (!drm_core_check_feature(dev, DRIVER_MODESET))
	100	return -EINVAL;
	101
	102
	103	mutex_lock(&file_priv->fbs_lock);
697cc9c8 DV	104	count = 0;
	105	fb_id = u64_to_user_ptr(card_res->fb_id_ptr);
	106	list_for_each_entry(fb, &file_priv->fbs, filp_head) {
	107	if (count < card_res->count_fbs &&
	108	put_user(fb->base.id, fb_id + count)) {
	109	mutex_unlock(&file_priv->fbs_lock);
	110	return -EFAULT;
28575f16	111	}
697cc9c8	112	count++;
28575f16	113	}
697cc9c8	114	card_res->count_fbs = count;
28575f16 DV	115	mutex_unlock(&file_priv->fbs_lock);
28575f16 DV	116
28575f16 DV	117	card_res->max_height = dev->mode_config.max_height;
	118	card_res->min_height = dev->mode_config.min_height;
	119	card_res->max_width = dev->mode_config.max_width;
	120	card_res->min_width = dev->mode_config.min_width;
	121
697cc9c8 DV	122	count = 0;
	123	crtc_id = u64_to_user_ptr(card_res->crtc_id_ptr);
	124	drm_for_each_crtc(crtc, dev) {
7de440db KP	125	if (drm_lease_held(file_priv, crtc->base.id)) {
	126	if (count < card_res->count_crtcs &&
	127	put_user(crtc->base.id, crtc_id + count))
	128	return -EFAULT;
	129	count++;
	130	}
28575f16	131	}
697cc9c8 DV	132	card_res->count_crtcs = count;
	133
	134	count = 0;
	135	encoder_id = u64_to_user_ptr(card_res->encoder_id_ptr);
	136	drm_for_each_encoder(encoder, dev) {
	137	if (count < card_res->count_encoders &&
613051da DV	138	put_user(encoder->base.id, encoder_id + count))
613051da DV	139	return -EFAULT;
697cc9c8	140	count++;
28575f16	141	}
697cc9c8 DV	142	card_res->count_encoders = count;
697cc9c8 DV	143
b982dab1	144	drm_connector_list_iter_begin(dev, &conn_iter);
697cc9c8 DV	145	count = 0;
697cc9c8 DV	146	connector_id = u64_to_user_ptr(card_res->connector_id_ptr);
613051da	147	drm_for_each_connector_iter(connector, &conn_iter) {
7de440db KP	148	if (drm_lease_held(file_priv, connector->base.id)) {
	149	if (count < card_res->count_connectors &&
	150	put_user(connector->base.id, connector_id + count)) {
	151	drm_connector_list_iter_end(&conn_iter);
	152	return -EFAULT;
	153	}
	154	count++;
28575f16 DV	155	}
28575f16 DV	156	}
697cc9c8	157	card_res->count_connectors = count;
b982dab1	158	drm_connector_list_iter_end(&conn_iter);
28575f16	159
28575f16 DV	160	return ret;
	161	}
	162
	163	/**
	164	* drm_mode_config_reset - call ->reset callbacks
	165	* @dev: drm device
	166	*
	167	* This functions calls all the crtc's, encoder's and connector's ->reset
	168	* callback. Drivers can use this in e.g. their driver load or resume code to
	169	* reset hardware and software state.
	170	*/
	171	void drm_mode_config_reset(struct drm_device *dev)
	172	{
	173	struct drm_crtc *crtc;
	174	struct drm_plane *plane;
	175	struct drm_encoder *encoder;
	176	struct drm_connector *connector;
613051da	177	struct drm_connector_list_iter conn_iter;
28575f16 DV	178
	179	drm_for_each_plane(plane, dev)
	180	if (plane->funcs->reset)
	181	plane->funcs->reset(plane);
	182
	183	drm_for_each_crtc(crtc, dev)
	184	if (crtc->funcs->reset)
	185	crtc->funcs->reset(crtc);
	186
	187	drm_for_each_encoder(encoder, dev)
	188	if (encoder->funcs->reset)
	189	encoder->funcs->reset(encoder);
	190
b982dab1	191	drm_connector_list_iter_begin(dev, &conn_iter);
613051da	192	drm_for_each_connector_iter(connector, &conn_iter)
28575f16 DV	193	if (connector->funcs->reset)
28575f16 DV	194	connector->funcs->reset(connector);
b982dab1	195	drm_connector_list_iter_end(&conn_iter);
28575f16 DV	196	}
	197	EXPORT_SYMBOL(drm_mode_config_reset);
	198
	199	/*
	200	* Global properties
	201	*/
	202	static const struct drm_prop_enum_list drm_plane_type_enum_list[] = {
	203	{ DRM_PLANE_TYPE_OVERLAY, "Overlay" },
	204	{ DRM_PLANE_TYPE_PRIMARY, "Primary" },
	205	{ DRM_PLANE_TYPE_CURSOR, "Cursor" },
	206	};
	207
	208	static int drm_mode_create_standard_properties(struct drm_device *dev)
	209	{
	210	struct drm_property *prop;
	211	int ret;
	212
	213	ret = drm_connector_create_standard_properties(dev);
	214	if (ret)
	215	return ret;
	216
	217	prop = drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE,
	218	"type", drm_plane_type_enum_list,
	219	ARRAY_SIZE(drm_plane_type_enum_list));
	220	if (!prop)
	221	return -ENOMEM;
	222	dev->mode_config.plane_type_property = prop;
	223
	224	prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
	225	"SRC_X", 0, UINT_MAX);
	226	if (!prop)
	227	return -ENOMEM;
	228	dev->mode_config.prop_src_x = prop;
	229
	230	prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
	231	"SRC_Y", 0, UINT_MAX);
	232	if (!prop)
	233	return -ENOMEM;
	234	dev->mode_config.prop_src_y = prop;
	235
	236	prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
	237	"SRC_W", 0, UINT_MAX);
	238	if (!prop)
	239	return -ENOMEM;
	240	dev->mode_config.prop_src_w = prop;
	241
	242	prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
	243	"SRC_H", 0, UINT_MAX);
	244	if (!prop)
	245	return -ENOMEM;
	246	dev->mode_config.prop_src_h = prop;
	247
	248	prop = drm_property_create_signed_range(dev, DRM_MODE_PROP_ATOMIC,
	249	"CRTC_X", INT_MIN, INT_MAX);
	250	if (!prop)
	251	return -ENOMEM;
	252	dev->mode_config.prop_crtc_x = prop;
	253
	254	prop = drm_property_create_signed_range(dev, DRM_MODE_PROP_ATOMIC,
	255	"CRTC_Y", INT_MIN, INT_MAX);
	256	if (!prop)
	257	return -ENOMEM;
	258	dev->mode_config.prop_crtc_y = prop;
	259
260	prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
261	"CRTC_W", 0, INT_MAX);
262	if (!prop)
263	return -ENOMEM;
264	dev->mode_config.prop_crtc_w = prop;
265
266	prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
267	"CRTC_H", 0, INT_MAX);
268	if (!prop)
269	return -ENOMEM;
270	dev->mode_config.prop_crtc_h = prop;
271
272	prop = drm_property_create_object(dev, DRM_MODE_PROP_ATOMIC,
273	"FB_ID", DRM_MODE_OBJECT_FB);
274	if (!prop)
275	return -ENOMEM;
276	dev->mode_config.prop_fb_id = prop;
277
96260142 GP	278	prop = drm_property_create_signed_range(dev, DRM_MODE_PROP_ATOMIC,
	279	"IN_FENCE_FD", -1, INT_MAX);
	280	if (!prop)
	281	return -ENOMEM;
	282	dev->mode_config.prop_in_fence_fd = prop;
	283
beaf5af4 GP	284	prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
	285	"OUT_FENCE_PTR", 0, U64_MAX);
	286	if (!prop)
	287	return -ENOMEM;
	288	dev->mode_config.prop_out_fence_ptr = prop;
	289
28575f16 DV	290	prop = drm_property_create_object(dev, DRM_MODE_PROP_ATOMIC,
	291	"CRTC_ID", DRM_MODE_OBJECT_CRTC);
	292	if (!prop)
	293	return -ENOMEM;
	294	dev->mode_config.prop_crtc_id = prop;
	295
	296	prop = drm_property_create_bool(dev, DRM_MODE_PROP_ATOMIC,
	297	"ACTIVE");
	298	if (!prop)
	299	return -ENOMEM;
	300	dev->mode_config.prop_active = prop;
	301
	302	prop = drm_property_create(dev,
	303	DRM_MODE_PROP_ATOMIC \| DRM_MODE_PROP_BLOB,
	304	"MODE_ID", 0);
	305	if (!prop)
	306	return -ENOMEM;
	307	dev->mode_config.prop_mode_id = prop;
	308
	309	prop = drm_property_create(dev,
	310	DRM_MODE_PROP_BLOB,
	311	"DEGAMMA_LUT", 0);
	312	if (!prop)
	313	return -ENOMEM;
	314	dev->mode_config.degamma_lut_property = prop;
	315
	316	prop = drm_property_create_range(dev,
	317	DRM_MODE_PROP_IMMUTABLE,
	318	"DEGAMMA_LUT_SIZE", 0, UINT_MAX);
	319	if (!prop)
	320	return -ENOMEM;
	321	dev->mode_config.degamma_lut_size_property = prop;
	322
	323	prop = drm_property_create(dev,
	324	DRM_MODE_PROP_BLOB,
	325	"CTM", 0);
	326	if (!prop)
	327	return -ENOMEM;
	328	dev->mode_config.ctm_property = prop;
	329
	330	prop = drm_property_create(dev,
	331	DRM_MODE_PROP_BLOB,
	332	"GAMMA_LUT", 0);
	333	if (!prop)
	334	return -ENOMEM;
	335	dev->mode_config.gamma_lut_property = prop;
	336
	337	prop = drm_property_create_range(dev,
	338	DRM_MODE_PROP_IMMUTABLE,
	339	"GAMMA_LUT_SIZE", 0, UINT_MAX);
	340	if (!prop)
	341	return -ENOMEM;
	342	dev->mode_config.gamma_lut_size_property = prop;
	343
db1689aa BW	344	prop = drm_property_create(dev,
	345	DRM_MODE_PROP_IMMUTABLE \| DRM_MODE_PROP_BLOB,
	346	"IN_FORMATS", 0);
	347	if (!prop)
	348	return -ENOMEM;
	349	dev->mode_config.modifiers_property = prop;
	350
28575f16 DV	351	return 0;
	352	}
	353
	354	/**
	355	* drm_mode_config_init - initialize DRM mode_configuration structure
	356	* @dev: DRM device
	357	*
	358	* Initialize @dev's mode_config structure, used for tracking the graphics
	359	* configuration of @dev.
	360	*
	361	* Since this initializes the modeset locks, no locking is possible. Which is no
	362	* problem, since this should happen single threaded at init time. It is the
	363	* driver's problem to ensure this guarantee.
	364	*
	365	*/
	366	void drm_mode_config_init(struct drm_device *dev)
	367	{
	368	mutex_init(&dev->mode_config.mutex);
	369	drm_modeset_lock_init(&dev->mode_config.connection_mutex);
	370	mutex_init(&dev->mode_config.idr_mutex);
	371	mutex_init(&dev->mode_config.fb_lock);
	372	mutex_init(&dev->mode_config.blob_lock);
	373	INIT_LIST_HEAD(&dev->mode_config.fb_list);
	374	INIT_LIST_HEAD(&dev->mode_config.crtc_list);
	375	INIT_LIST_HEAD(&dev->mode_config.connector_list);
	376	INIT_LIST_HEAD(&dev->mode_config.encoder_list);
	377	INIT_LIST_HEAD(&dev->mode_config.property_list);
	378	INIT_LIST_HEAD(&dev->mode_config.property_blob_list);
	379	INIT_LIST_HEAD(&dev->mode_config.plane_list);
	380	idr_init(&dev->mode_config.crtc_idr);
	381	idr_init(&dev->mode_config.tile_idr);
	382	ida_init(&dev->mode_config.connector_ida);
613051da	383	spin_lock_init(&dev->mode_config.connector_list_lock);
28575f16	384
28575f16	385	drm_mode_create_standard_properties(dev);
28575f16 DV	386
	387	/* Just to be sure */
	388	dev->mode_config.num_fb = 0;
	389	dev->mode_config.num_connector = 0;
	390	dev->mode_config.num_crtc = 0;
	391	dev->mode_config.num_encoder = 0;
28575f16 DV	392	dev->mode_config.num_total_plane = 0;
	393	}
	394	EXPORT_SYMBOL(drm_mode_config_init);
	395
	396	/**
	397	* drm_mode_config_cleanup - free up DRM mode_config info
	398	* @dev: DRM device
	399	*
	400	* Free up all the connectors and CRTCs associated with this DRM device, then
	401	* free up the framebuffers and associated buffer objects.
	402	*
	403	* Note that since this /should/ happen single-threaded at driver/device
	404	* teardown time, no locking is required. It's the driver's job to ensure that
	405	* this guarantee actually holds true.
	406	*
	407	* FIXME: cleanup any dangling user buffer objects too
	408	*/
	409	void drm_mode_config_cleanup(struct drm_device *dev)
	410	{
2ab8c5f8 DV	411	struct drm_connector *connector;
2ab8c5f8 DV	412	struct drm_connector_list_iter conn_iter;
28575f16 DV	413	struct drm_crtc crtc, ct;
	414	struct drm_encoder encoder, enct;
	415	struct drm_framebuffer fb, fbt;
	416	struct drm_property property, pt;
	417	struct drm_property_blob blob, bt;
	418	struct drm_plane plane, plt;
	419
	420	list_for_each_entry_safe(encoder, enct, &dev->mode_config.encoder_list,
	421	head) {
	422	encoder->funcs->destroy(encoder);
	423	}
	424
b982dab1	425	drm_connector_list_iter_begin(dev, &conn_iter);
2ab8c5f8 DV	426	drm_for_each_connector_iter(connector, &conn_iter) {
	427	/* drm_connector_list_iter holds an full reference to the
	428	* current connector itself, which means it is inherently safe
	429	* against unreferencing the current connector - but not against
	430	* deleting it right away. */
ad093607	431	drm_connector_put(connector);
28575f16	432	}
b982dab1	433	drm_connector_list_iter_end(&conn_iter);
d352f352	434	if (WARN_ON(!list_empty(&dev->mode_config.connector_list))) {
b982dab1	435	drm_connector_list_iter_begin(dev, &conn_iter);
d352f352 CW	436	drm_for_each_connector_iter(connector, &conn_iter)
d352f352 CW	437	DRM_ERROR("connector %s leaked!\n", connector->name);
b982dab1	438	drm_connector_list_iter_end(&conn_iter);
d352f352	439	}
28575f16 DV	440
	441	list_for_each_entry_safe(property, pt, &dev->mode_config.property_list,
	442	head) {
	443	drm_property_destroy(dev, property);
	444	}
	445
	446	list_for_each_entry_safe(plane, plt, &dev->mode_config.plane_list,
	447	head) {
	448	plane->funcs->destroy(plane);
	449	}
	450
	451	list_for_each_entry_safe(crtc, ct, &dev->mode_config.crtc_list, head) {
	452	crtc->funcs->destroy(crtc);
	453	}
	454
	455	list_for_each_entry_safe(blob, bt, &dev->mode_config.property_blob_list,
	456	head_global) {
6472e509	457	drm_property_blob_put(blob);
28575f16 DV	458	}
	459
	460	/*
	461	* Single-threaded teardown context, so it's not required to grab the
	462	* fb_lock to protect against concurrent fb_list access. Contrary, it
	463	* would actually deadlock with the drm_framebuffer_cleanup function.
	464	*
	465	* Also, if there are any framebuffers left, that's a driver leak now,
	466	* so politely WARN about this.
	467	*/
	468	WARN_ON(!list_empty(&dev->mode_config.fb_list));
	469	list_for_each_entry_safe(fb, fbt, &dev->mode_config.fb_list, head) {
	470	drm_framebuffer_free(&fb->base.refcount);
	471	}
	472
	473	ida_destroy(&dev->mode_config.connector_ida);
	474	idr_destroy(&dev->mode_config.tile_idr);
	475	idr_destroy(&dev->mode_config.crtc_idr);
	476	drm_modeset_lock_fini(&dev->mode_config.connection_mutex);
	477	}
	478	EXPORT_SYMBOL(drm_mode_config_cleanup);