[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_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 list_head *lh;
	struct drm_framebuffer *fb;
	struct drm_connector *connector;
	struct drm_crtc *crtc;
	struct drm_encoder *encoder;
	int ret = 0;
	int connector_count = 0;
	int crtc_count = 0;
	int fb_count = 0;
	int encoder_count = 0;
	int copied = 0;
	uint32_t __user *fb_id;
	uint32_t __user *crtc_id;
	uint32_t __user *connector_id;
	uint32_t __user *encoder_id;

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


	mutex_lock(&file_priv->fbs_lock);
	/*
	 * For the non-control nodes we need to limit the list of resources
	 * by IDs in the group list for this node
	 */
	list_for_each(lh, &file_priv->fbs)
		fb_count++;

	/* handle this in 4 parts */
	/* FBs */
	if (card_res->count_fbs >= fb_count) {
		copied = 0;
		fb_id = (uint32_t __user *)(unsigned long)card_res->fb_id_ptr;
		list_for_each_entry(fb, &file_priv->fbs, filp_head) {
			if (put_user(fb->base.id, fb_id + copied)) {
				mutex_unlock(&file_priv->fbs_lock);
				return -EFAULT;
			}
			copied++;
		}
	}
	card_res->count_fbs = fb_count;
	mutex_unlock(&file_priv->fbs_lock);

	/* mode_config.mutex protects the connector list against e.g. DP MST
	 * connector hot-adding. CRTC/Plane lists are invariant. */
	mutex_lock(&dev->mode_config.mutex);
	drm_for_each_crtc(crtc, dev)
		crtc_count++;

	drm_for_each_connector(connector, dev)
		connector_count++;

	drm_for_each_encoder(encoder, dev)
		encoder_count++;

	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;

	/* CRTCs */
	if (card_res->count_crtcs >= crtc_count) {
		copied = 0;
		crtc_id = (uint32_t __user *)(unsigned long)card_res->crtc_id_ptr;
		drm_for_each_crtc(crtc, dev) {
			if (put_user(crtc->base.id, crtc_id + copied)) {
				ret = -EFAULT;
				goto out;
			}
			copied++;
		}
	}
	card_res->count_crtcs = crtc_count;

	/* Encoders */
	if (card_res->count_encoders >= encoder_count) {
		copied = 0;
		encoder_id = (uint32_t __user *)(unsigned long)card_res->encoder_id_ptr;
		drm_for_each_encoder(encoder, dev) {
			if (put_user(encoder->base.id, encoder_id +
				     copied)) {
				ret = -EFAULT;
				goto out;
			}
			copied++;
		}
	}
	card_res->count_encoders = encoder_count;

	/* Connectors */
	if (card_res->count_connectors >= connector_count) {
		copied = 0;
		connector_id = (uint32_t __user *)(unsigned long)card_res->connector_id_ptr;
		drm_for_each_connector(connector, dev) {
			if (put_user(connector->base.id,
				     connector_id + copied)) {
				ret = -EFAULT;
				goto out;
			}
			copied++;
		}
	}
	card_res->count_connectors = connector_count;

out:
	mutex_unlock(&dev->mode_config.mutex);
	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;

	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);

	mutex_lock(&dev->mode_config.mutex);
	drm_for_each_connector(connector, dev)
		if (connector->funcs->reset)
			connector->funcs->reset(connector);
	mutex_unlock(&dev->mode_config.mutex);
}
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_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;

	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);

	drm_modeset_lock_all(dev);
	drm_mode_create_standard_properties(dev);
	drm_modeset_unlock_all(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_overlay_plane = 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, *ot;
	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);
	}

	list_for_each_entry_safe(connector, ot,
				 &dev->mode_config.connector_list, head) {
		connector->funcs->destroy(connector);
	}

	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_unreference_blob(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
	23	#include <drm/drm_mode_config.h>
	24	#include <drm/drmP.h>
	25
	26	#include "drm_crtc_internal.h"
	27	#include "drm_internal.h"
	28
	29	int drm_modeset_register_all(struct drm_device *dev)
	30	{
	31	int ret;
	32
	33	ret = drm_plane_register_all(dev);
	34	if (ret)
	35	goto err_plane;
	36
	37	ret = drm_crtc_register_all(dev);
	38	if (ret)
	39	goto err_crtc;
	40
	41	ret = drm_encoder_register_all(dev);
	42	if (ret)
	43	goto err_encoder;
	44
	45	ret = drm_connector_register_all(dev);
	46	if (ret)
	47	goto err_connector;
	48
	49	return 0;
	50
	51	err_connector:
	52	drm_encoder_unregister_all(dev);
	53	err_encoder:
	54	drm_crtc_unregister_all(dev);
	55	err_crtc:
	56	drm_plane_unregister_all(dev);
	57	err_plane:
	58	return ret;
	59	}
	60
	61	void drm_modeset_unregister_all(struct drm_device *dev)
	62	{
	63	drm_connector_unregister_all(dev);
	64	drm_encoder_unregister_all(dev);
65	drm_crtc_unregister_all(dev);
66	drm_plane_unregister_all(dev);
67	}
68
69	/**
70	* drm_mode_getresources - get graphics configuration
71	* @dev: drm device for the ioctl
72	* @data: data pointer for the ioctl
73	* @file_priv: drm file for the ioctl call
74	*
75	* Construct a set of configuration description structures and return
76	* them to the user, including CRTC, connector and framebuffer configuration.
77	*
78	* Called by the user via ioctl.
79	*
80	* Returns:
81	* Zero on success, negative errno on failure.
82	*/
83	int drm_mode_getresources(struct drm_device dev, void data,
84	struct drm_file *file_priv)
85	{
86	struct drm_mode_card_res *card_res = data;
87	struct list_head *lh;
88	struct drm_framebuffer *fb;
89	struct drm_connector *connector;
90	struct drm_crtc *crtc;
91	struct drm_encoder *encoder;
92	int ret = 0;
93	int connector_count = 0;
94	int crtc_count = 0;
95	int fb_count = 0;
96	int encoder_count = 0;
97	int copied = 0;
98	uint32_t __user *fb_id;
99	uint32_t __user *crtc_id;
100	uint32_t __user *connector_id;
101	uint32_t __user *encoder_id;
102
103	if (!drm_core_check_feature(dev, DRIVER_MODESET))
104	return -EINVAL;
105
106
107	mutex_lock(&file_priv->fbs_lock);
108	/*
109	* For the non-control nodes we need to limit the list of resources
110	* by IDs in the group list for this node
111	*/
112	list_for_each(lh, &file_priv->fbs)
113	fb_count++;
114
115	/* handle this in 4 parts */
116	/* FBs */
117	if (card_res->count_fbs >= fb_count) {
118	copied = 0;
119	fb_id = (uint32_t __user *)(unsigned long)card_res->fb_id_ptr;
120	list_for_each_entry(fb, &file_priv->fbs, filp_head) {
121	if (put_user(fb->base.id, fb_id + copied)) {
122	mutex_unlock(&file_priv->fbs_lock);
123	return -EFAULT;
124	}
125	copied++;
126	}
127	}
128	card_res->count_fbs = fb_count;
129	mutex_unlock(&file_priv->fbs_lock);
130
131	/* mode_config.mutex protects the connector list against e.g. DP MST
132	* connector hot-adding. CRTC/Plane lists are invariant. */
133	mutex_lock(&dev->mode_config.mutex);
134	drm_for_each_crtc(crtc, dev)
135	crtc_count++;
136
137	drm_for_each_connector(connector, dev)
138	connector_count++;
139
140	drm_for_each_encoder(encoder, dev)
141	encoder_count++;
142
143	card_res->max_height = dev->mode_config.max_height;
144	card_res->min_height = dev->mode_config.min_height;
145	card_res->max_width = dev->mode_config.max_width;
146	card_res->min_width = dev->mode_config.min_width;
147
148	/* CRTCs */
149	if (card_res->count_crtcs >= crtc_count) {
150	copied = 0;
151	crtc_id = (uint32_t __user *)(unsigned long)card_res->crtc_id_ptr;
152	drm_for_each_crtc(crtc, dev) {
153	if (put_user(crtc->base.id, crtc_id + copied)) {
154	ret = -EFAULT;
155	goto out;
156	}
157	copied++;
158	}
159	}
160	card_res->count_crtcs = crtc_count;
161
162	/* Encoders */
163	if (card_res->count_encoders >= encoder_count) {
164	copied = 0;
165	encoder_id = (uint32_t __user *)(unsigned long)card_res->encoder_id_ptr;
166	drm_for_each_encoder(encoder, dev) {
167	if (put_user(encoder->base.id, encoder_id +
168	copied)) {
169	ret = -EFAULT;
170	goto out;
171	}
172	copied++;
173	}
174	}
175	card_res->count_encoders = encoder_count;
176
177	/* Connectors */
178	if (card_res->count_connectors >= connector_count) {
179	copied = 0;
180	connector_id = (uint32_t __user *)(unsigned long)card_res->connector_id_ptr;
181	drm_for_each_connector(connector, dev) {
182	if (put_user(connector->base.id,
183	connector_id + copied)) {
184	ret = -EFAULT;
185	goto out;
186	}
187	copied++;
188	}
189	}
190	card_res->count_connectors = connector_count;
191
192	out:
193	mutex_unlock(&dev->mode_config.mutex);
194	return ret;
195	}
196
197	/**
198	* drm_mode_config_reset - call ->reset callbacks
199	* @dev: drm device
200	*
201	* This functions calls all the crtc's, encoder's and connector's ->reset
202	* callback. Drivers can use this in e.g. their driver load or resume code to
203	* reset hardware and software state.
204	*/
205	void drm_mode_config_reset(struct drm_device *dev)
206	{
207	struct drm_crtc *crtc;
208	struct drm_plane *plane;
209	struct drm_encoder *encoder;
210	struct drm_connector *connector;
211
212	drm_for_each_plane(plane, dev)
213	if (plane->funcs->reset)
214	plane->funcs->reset(plane);
215
216	drm_for_each_crtc(crtc, dev)
217	if (crtc->funcs->reset)
218	crtc->funcs->reset(crtc);
219
220	drm_for_each_encoder(encoder, dev)
221	if (encoder->funcs->reset)
222	encoder->funcs->reset(encoder);
223
224	mutex_lock(&dev->mode_config.mutex);
225	drm_for_each_connector(connector, dev)
226	if (connector->funcs->reset)
227	connector->funcs->reset(connector);
228	mutex_unlock(&dev->mode_config.mutex);
229	}
230	EXPORT_SYMBOL(drm_mode_config_reset);
231
232	/*
233	* Global properties
234	*/
235	static const struct drm_prop_enum_list drm_plane_type_enum_list[] = {
236	{ DRM_PLANE_TYPE_OVERLAY, "Overlay" },
237	{ DRM_PLANE_TYPE_PRIMARY, "Primary" },
238	{ DRM_PLANE_TYPE_CURSOR, "Cursor" },
239	};
240
241	static int drm_mode_create_standard_properties(struct drm_device *dev)
242	{
243	struct drm_property *prop;
244	int ret;
245
246	ret = drm_connector_create_standard_properties(dev);
247	if (ret)
248	return ret;
249
250	prop = drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE,
251	"type", drm_plane_type_enum_list,
252	ARRAY_SIZE(drm_plane_type_enum_list));
253	if (!prop)
254	return -ENOMEM;
255	dev->mode_config.plane_type_property = prop;
256
257	prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
258	"SRC_X", 0, UINT_MAX);
259	if (!prop)
260	return -ENOMEM;
261	dev->mode_config.prop_src_x = prop;
262
263	prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
264	"SRC_Y", 0, UINT_MAX);
265	if (!prop)
266	return -ENOMEM;
267	dev->mode_config.prop_src_y = prop;
268
269	prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
270	"SRC_W", 0, UINT_MAX);
271	if (!prop)
272	return -ENOMEM;
273	dev->mode_config.prop_src_w = prop;
274
275	prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
276	"SRC_H", 0, UINT_MAX);
277	if (!prop)
278	return -ENOMEM;
279	dev->mode_config.prop_src_h = prop;
280
281	prop = drm_property_create_signed_range(dev, DRM_MODE_PROP_ATOMIC,
282	"CRTC_X", INT_MIN, INT_MAX);
283	if (!prop)
284	return -ENOMEM;
285	dev->mode_config.prop_crtc_x = prop;
286
287	prop = drm_property_create_signed_range(dev, DRM_MODE_PROP_ATOMIC,
288	"CRTC_Y", INT_MIN, INT_MAX);
289	if (!prop)
290	return -ENOMEM;
291	dev->mode_config.prop_crtc_y = prop;
292
293	prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
294	"CRTC_W", 0, INT_MAX);
295	if (!prop)
296	return -ENOMEM;
297	dev->mode_config.prop_crtc_w = prop;
298
299	prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
300	"CRTC_H", 0, INT_MAX);
301	if (!prop)
302	return -ENOMEM;
303	dev->mode_config.prop_crtc_h = prop;
304
305	prop = drm_property_create_object(dev, DRM_MODE_PROP_ATOMIC,
306	"FB_ID", DRM_MODE_OBJECT_FB);
307	if (!prop)
308	return -ENOMEM;
309	dev->mode_config.prop_fb_id = prop;
310
96260142 GP	311	prop = drm_property_create_signed_range(dev, DRM_MODE_PROP_ATOMIC,
	312	"IN_FENCE_FD", -1, INT_MAX);
	313	if (!prop)
	314	return -ENOMEM;
	315	dev->mode_config.prop_in_fence_fd = prop;
	316
28575f16 DV	317	prop = drm_property_create_object(dev, DRM_MODE_PROP_ATOMIC,
	318	"CRTC_ID", DRM_MODE_OBJECT_CRTC);
	319	if (!prop)
	320	return -ENOMEM;
	321	dev->mode_config.prop_crtc_id = prop;
	322
	323	prop = drm_property_create_bool(dev, DRM_MODE_PROP_ATOMIC,
	324	"ACTIVE");
	325	if (!prop)
	326	return -ENOMEM;
	327	dev->mode_config.prop_active = prop;
	328
	329	prop = drm_property_create(dev,
	330	DRM_MODE_PROP_ATOMIC \| DRM_MODE_PROP_BLOB,
	331	"MODE_ID", 0);
	332	if (!prop)
	333	return -ENOMEM;
	334	dev->mode_config.prop_mode_id = prop;
	335
	336	prop = drm_property_create(dev,
	337	DRM_MODE_PROP_BLOB,
	338	"DEGAMMA_LUT", 0);
	339	if (!prop)
	340	return -ENOMEM;
	341	dev->mode_config.degamma_lut_property = prop;
	342
	343	prop = drm_property_create_range(dev,
	344	DRM_MODE_PROP_IMMUTABLE,
	345	"DEGAMMA_LUT_SIZE", 0, UINT_MAX);
	346	if (!prop)
	347	return -ENOMEM;
	348	dev->mode_config.degamma_lut_size_property = prop;
	349
	350	prop = drm_property_create(dev,
	351	DRM_MODE_PROP_BLOB,
	352	"CTM", 0);
	353	if (!prop)
	354	return -ENOMEM;
	355	dev->mode_config.ctm_property = prop;
	356
	357	prop = drm_property_create(dev,
	358	DRM_MODE_PROP_BLOB,
	359	"GAMMA_LUT", 0);
	360	if (!prop)
	361	return -ENOMEM;
	362	dev->mode_config.gamma_lut_property = prop;
	363
	364	prop = drm_property_create_range(dev,
	365	DRM_MODE_PROP_IMMUTABLE,
	366	"GAMMA_LUT_SIZE", 0, UINT_MAX);
	367	if (!prop)
	368	return -ENOMEM;
	369	dev->mode_config.gamma_lut_size_property = prop;
	370
	371	return 0;
	372	}
	373
	374	/**
	375	* drm_mode_config_init - initialize DRM mode_configuration structure
	376	* @dev: DRM device
	377	*
	378	* Initialize @dev's mode_config structure, used for tracking the graphics
	379	* configuration of @dev.
	380	*
381	* Since this initializes the modeset locks, no locking is possible. Which is no
382	* problem, since this should happen single threaded at init time. It is the
383	* driver's problem to ensure this guarantee.
384	*
385	*/
386	void drm_mode_config_init(struct drm_device *dev)
387	{
388	mutex_init(&dev->mode_config.mutex);
389	drm_modeset_lock_init(&dev->mode_config.connection_mutex);
390	mutex_init(&dev->mode_config.idr_mutex);
391	mutex_init(&dev->mode_config.fb_lock);
392	mutex_init(&dev->mode_config.blob_lock);
393	INIT_LIST_HEAD(&dev->mode_config.fb_list);
394	INIT_LIST_HEAD(&dev->mode_config.crtc_list);
395	INIT_LIST_HEAD(&dev->mode_config.connector_list);
396	INIT_LIST_HEAD(&dev->mode_config.encoder_list);
397	INIT_LIST_HEAD(&dev->mode_config.property_list);
398	INIT_LIST_HEAD(&dev->mode_config.property_blob_list);
399	INIT_LIST_HEAD(&dev->mode_config.plane_list);
400	idr_init(&dev->mode_config.crtc_idr);
401	idr_init(&dev->mode_config.tile_idr);
402	ida_init(&dev->mode_config.connector_ida);
403
404	drm_modeset_lock_all(dev);
405	drm_mode_create_standard_properties(dev);
406	drm_modeset_unlock_all(dev);
407
408	/* Just to be sure */
409	dev->mode_config.num_fb = 0;
410	dev->mode_config.num_connector = 0;
411	dev->mode_config.num_crtc = 0;
412	dev->mode_config.num_encoder = 0;
413	dev->mode_config.num_overlay_plane = 0;
414	dev->mode_config.num_total_plane = 0;
415	}
416	EXPORT_SYMBOL(drm_mode_config_init);
417
418	/**
419	* drm_mode_config_cleanup - free up DRM mode_config info
420	* @dev: DRM device
421	*
422	* Free up all the connectors and CRTCs associated with this DRM device, then
423	* free up the framebuffers and associated buffer objects.
424	*
425	* Note that since this /should/ happen single-threaded at driver/device
426	* teardown time, no locking is required. It's the driver's job to ensure that
427	* this guarantee actually holds true.
428	*
429	* FIXME: cleanup any dangling user buffer objects too
430	*/
431	void drm_mode_config_cleanup(struct drm_device *dev)
432	{
433	struct drm_connector connector, ot;
434	struct drm_crtc crtc, ct;
435	struct drm_encoder encoder, enct;
436	struct drm_framebuffer fb, fbt;
437	struct drm_property property, pt;
438	struct drm_property_blob blob, bt;
439	struct drm_plane plane, plt;
440
441	list_for_each_entry_safe(encoder, enct, &dev->mode_config.encoder_list,
442	head) {
443	encoder->funcs->destroy(encoder);
444	}
445
446	list_for_each_entry_safe(connector, ot,
447	&dev->mode_config.connector_list, head) {
448	connector->funcs->destroy(connector);
449	}
450
451	list_for_each_entry_safe(property, pt, &dev->mode_config.property_list,
452	head) {
453	drm_property_destroy(dev, property);
454	}
455
456	list_for_each_entry_safe(plane, plt, &dev->mode_config.plane_list,
457	head) {
458	plane->funcs->destroy(plane);
459	}
460
461	list_for_each_entry_safe(crtc, ct, &dev->mode_config.crtc_list, head) {
462	crtc->funcs->destroy(crtc);
463	}
464
465	list_for_each_entry_safe(blob, bt, &dev->mode_config.property_blob_list,
466	head_global) {
467	drm_property_unreference_blob(blob);
468	}
469
470	/*
471	* Single-threaded teardown context, so it's not required to grab the
472	* fb_lock to protect against concurrent fb_list access. Contrary, it
473	* would actually deadlock with the drm_framebuffer_cleanup function.
474	*
475	* Also, if there are any framebuffers left, that's a driver leak now,
476	* so politely WARN about this.
477	*/
478	WARN_ON(!list_empty(&dev->mode_config.fb_list));
479	list_for_each_entry_safe(fb, fbt, &dev->mode_config.fb_list, head) {
480	drm_framebuffer_free(&fb->base.refcount);
481	}
482
483	ida_destroy(&dev->mode_config.connector_ida);
484	idr_destroy(&dev->mode_config.tile_idr);
485	idr_destroy(&dev->mode_config.crtc_idr);
486	drm_modeset_lock_fini(&dev->mode_config.connection_mutex);
487	}
488	EXPORT_SYMBOL(drm_mode_config_cleanup);