[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 -EOPNOTSUPP;

	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) {
		/* only expose writeback connectors if userspace understands them */
		if (!file_priv->writeback_connectors &&
		    (connector->connector_type == DRM_MODE_CONNECTOR_WRITEBACK))
			continue;

		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(dev, DRM_MODE_PROP_BLOB, "FB_DAMAGE_CLIPS",
				   0);
	if (!prop)
		return -ENOMEM;
	dev->mode_config.prop_fb_damage_clips = 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_bool(dev, 0,
			"VRR_ENABLED");
	if (!prop)
		return -ENOMEM;
	dev->mode_config.prop_vrr_enabled = 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);

	init_llist_head(&dev->mode_config.connector_free_list);
	INIT_WORK(&dev->mode_config.connector_free_work, drm_connector_free_work_fn);

	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);
	/* connector_iter drops references in a work item. */
	flush_work(&dev->mode_config.connector_free_work);
	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) {
		struct drm_printer p = drm_debug_printer("[leaked fb]");
		drm_printf(&p, "framebuffer[%u]:\n", fb->base.id);
		drm_framebuffer_print_info(&p, 1, fb);
		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
28575f16 DV	99	if (!drm_core_check_feature(dev, DRIVER_MODESET))
69fdf420	100	return -EOPNOTSUPP;
28575f16 DV	101
28575f16 DV	102	mutex_lock(&file_priv->fbs_lock);
697cc9c8 DV	103	count = 0;
	104	fb_id = u64_to_user_ptr(card_res->fb_id_ptr);
	105	list_for_each_entry(fb, &file_priv->fbs, filp_head) {
	106	if (count < card_res->count_fbs &&
	107	put_user(fb->base.id, fb_id + count)) {
	108	mutex_unlock(&file_priv->fbs_lock);
	109	return -EFAULT;
28575f16	110	}
697cc9c8	111	count++;
28575f16	112	}
697cc9c8	113	card_res->count_fbs = count;
28575f16 DV	114	mutex_unlock(&file_priv->fbs_lock);
28575f16 DV	115
28575f16 DV	116	card_res->max_height = dev->mode_config.max_height;
	117	card_res->min_height = dev->mode_config.min_height;
	118	card_res->max_width = dev->mode_config.max_width;
	119	card_res->min_width = dev->mode_config.min_width;
	120
697cc9c8 DV	121	count = 0;
	122	crtc_id = u64_to_user_ptr(card_res->crtc_id_ptr);
	123	drm_for_each_crtc(crtc, dev) {
7de440db KP	124	if (drm_lease_held(file_priv, crtc->base.id)) {
	125	if (count < card_res->count_crtcs &&
	126	put_user(crtc->base.id, crtc_id + count))
	127	return -EFAULT;
	128	count++;
	129	}
28575f16	130	}
697cc9c8 DV	131	card_res->count_crtcs = count;
	132
	133	count = 0;
	134	encoder_id = u64_to_user_ptr(card_res->encoder_id_ptr);
	135	drm_for_each_encoder(encoder, dev) {
	136	if (count < card_res->count_encoders &&
613051da DV	137	put_user(encoder->base.id, encoder_id + count))
613051da DV	138	return -EFAULT;
697cc9c8	139	count++;
28575f16	140	}
697cc9c8 DV	141	card_res->count_encoders = count;
697cc9c8 DV	142
b982dab1	143	drm_connector_list_iter_begin(dev, &conn_iter);
697cc9c8 DV	144	count = 0;
697cc9c8 DV	145	connector_id = u64_to_user_ptr(card_res->connector_id_ptr);
613051da	146	drm_for_each_connector_iter(connector, &conn_iter) {
d67b6a20 LD	147	/* only expose writeback connectors if userspace understands them */
	148	if (!file_priv->writeback_connectors &&
	149	(connector->connector_type == DRM_MODE_CONNECTOR_WRITEBACK))
	150	continue;
	151
7de440db KP	152	if (drm_lease_held(file_priv, connector->base.id)) {
	153	if (count < card_res->count_connectors &&
	154	put_user(connector->base.id, connector_id + count)) {
	155	drm_connector_list_iter_end(&conn_iter);
	156	return -EFAULT;
	157	}
	158	count++;
28575f16 DV	159	}
28575f16 DV	160	}
697cc9c8	161	card_res->count_connectors = count;
b982dab1	162	drm_connector_list_iter_end(&conn_iter);
28575f16	163
28575f16 DV	164	return ret;
	165	}
	166
	167	/**
	168	* drm_mode_config_reset - call ->reset callbacks
	169	* @dev: drm device
	170	*
	171	* This functions calls all the crtc's, encoder's and connector's ->reset
	172	* callback. Drivers can use this in e.g. their driver load or resume code to
	173	* reset hardware and software state.
	174	*/
	175	void drm_mode_config_reset(struct drm_device *dev)
	176	{
	177	struct drm_crtc *crtc;
	178	struct drm_plane *plane;
	179	struct drm_encoder *encoder;
	180	struct drm_connector *connector;
613051da	181	struct drm_connector_list_iter conn_iter;
28575f16 DV	182
	183	drm_for_each_plane(plane, dev)
	184	if (plane->funcs->reset)
	185	plane->funcs->reset(plane);
	186
	187	drm_for_each_crtc(crtc, dev)
	188	if (crtc->funcs->reset)
	189	crtc->funcs->reset(crtc);
	190
	191	drm_for_each_encoder(encoder, dev)
	192	if (encoder->funcs->reset)
	193	encoder->funcs->reset(encoder);
	194
b982dab1	195	drm_connector_list_iter_begin(dev, &conn_iter);
613051da	196	drm_for_each_connector_iter(connector, &conn_iter)
28575f16 DV	197	if (connector->funcs->reset)
28575f16 DV	198	connector->funcs->reset(connector);
b982dab1	199	drm_connector_list_iter_end(&conn_iter);
28575f16 DV	200	}
	201	EXPORT_SYMBOL(drm_mode_config_reset);
	202
	203	/*
	204	* Global properties
	205	*/
	206	static const struct drm_prop_enum_list drm_plane_type_enum_list[] = {
	207	{ DRM_PLANE_TYPE_OVERLAY, "Overlay" },
	208	{ DRM_PLANE_TYPE_PRIMARY, "Primary" },
	209	{ DRM_PLANE_TYPE_CURSOR, "Cursor" },
	210	};
	211
	212	static int drm_mode_create_standard_properties(struct drm_device *dev)
	213	{
	214	struct drm_property *prop;
	215	int ret;
	216
	217	ret = drm_connector_create_standard_properties(dev);
	218	if (ret)
	219	return ret;
	220
	221	prop = drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE,
	222	"type", drm_plane_type_enum_list,
	223	ARRAY_SIZE(drm_plane_type_enum_list));
	224	if (!prop)
	225	return -ENOMEM;
	226	dev->mode_config.plane_type_property = prop;
	227
	228	prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
	229	"SRC_X", 0, UINT_MAX);
	230	if (!prop)
	231	return -ENOMEM;
	232	dev->mode_config.prop_src_x = prop;
	233
	234	prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
	235	"SRC_Y", 0, UINT_MAX);
	236	if (!prop)
	237	return -ENOMEM;
	238	dev->mode_config.prop_src_y = prop;
	239
	240	prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
	241	"SRC_W", 0, UINT_MAX);
	242	if (!prop)
	243	return -ENOMEM;
	244	dev->mode_config.prop_src_w = prop;
	245
	246	prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
	247	"SRC_H", 0, UINT_MAX);
	248	if (!prop)
	249	return -ENOMEM;
	250	dev->mode_config.prop_src_h = prop;
	251
	252	prop = drm_property_create_signed_range(dev, DRM_MODE_PROP_ATOMIC,
	253	"CRTC_X", INT_MIN, INT_MAX);
	254	if (!prop)
	255	return -ENOMEM;
	256	dev->mode_config.prop_crtc_x = prop;
	257
	258	prop = drm_property_create_signed_range(dev, DRM_MODE_PROP_ATOMIC,
	259	"CRTC_Y", INT_MIN, INT_MAX);
	260	if (!prop)
	261	return -ENOMEM;
	262	dev->mode_config.prop_crtc_y = prop;
	263
264	prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
265	"CRTC_W", 0, INT_MAX);
266	if (!prop)
267	return -ENOMEM;
268	dev->mode_config.prop_crtc_w = prop;
269
270	prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
271	"CRTC_H", 0, INT_MAX);
272	if (!prop)
273	return -ENOMEM;
274	dev->mode_config.prop_crtc_h = prop;
275
276	prop = drm_property_create_object(dev, DRM_MODE_PROP_ATOMIC,
277	"FB_ID", DRM_MODE_OBJECT_FB);
278	if (!prop)
279	return -ENOMEM;
280	dev->mode_config.prop_fb_id = prop;
281
96260142 GP	282	prop = drm_property_create_signed_range(dev, DRM_MODE_PROP_ATOMIC,
	283	"IN_FENCE_FD", -1, INT_MAX);
	284	if (!prop)
	285	return -ENOMEM;
	286	dev->mode_config.prop_in_fence_fd = prop;
	287
beaf5af4 GP	288	prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
	289	"OUT_FENCE_PTR", 0, U64_MAX);
	290	if (!prop)
	291	return -ENOMEM;
	292	dev->mode_config.prop_out_fence_ptr = prop;
	293
28575f16 DV	294	prop = drm_property_create_object(dev, DRM_MODE_PROP_ATOMIC,
	295	"CRTC_ID", DRM_MODE_OBJECT_CRTC);
	296	if (!prop)
	297	return -ENOMEM;
	298	dev->mode_config.prop_crtc_id = prop;
	299
d3b21767 LS	300	prop = drm_property_create(dev, DRM_MODE_PROP_BLOB, "FB_DAMAGE_CLIPS",
	301	0);
	302	if (!prop)
	303	return -ENOMEM;
	304	dev->mode_config.prop_fb_damage_clips = prop;
	305
28575f16 DV	306	prop = drm_property_create_bool(dev, DRM_MODE_PROP_ATOMIC,
	307	"ACTIVE");
	308	if (!prop)
	309	return -ENOMEM;
	310	dev->mode_config.prop_active = prop;
	311
	312	prop = drm_property_create(dev,
	313	DRM_MODE_PROP_ATOMIC \| DRM_MODE_PROP_BLOB,
	314	"MODE_ID", 0);
	315	if (!prop)
	316	return -ENOMEM;
	317	dev->mode_config.prop_mode_id = prop;
	318
1398958c NK	319	prop = drm_property_create_bool(dev, 0,
	320	"VRR_ENABLED");
	321	if (!prop)
	322	return -ENOMEM;
	323	dev->mode_config.prop_vrr_enabled = prop;
	324
28575f16 DV	325	prop = drm_property_create(dev,
	326	DRM_MODE_PROP_BLOB,
	327	"DEGAMMA_LUT", 0);
	328	if (!prop)
	329	return -ENOMEM;
	330	dev->mode_config.degamma_lut_property = prop;
	331
	332	prop = drm_property_create_range(dev,
	333	DRM_MODE_PROP_IMMUTABLE,
	334	"DEGAMMA_LUT_SIZE", 0, UINT_MAX);
	335	if (!prop)
	336	return -ENOMEM;
	337	dev->mode_config.degamma_lut_size_property = prop;
	338
	339	prop = drm_property_create(dev,
	340	DRM_MODE_PROP_BLOB,
	341	"CTM", 0);
	342	if (!prop)
	343	return -ENOMEM;
	344	dev->mode_config.ctm_property = prop;
	345
	346	prop = drm_property_create(dev,
	347	DRM_MODE_PROP_BLOB,
	348	"GAMMA_LUT", 0);
	349	if (!prop)
	350	return -ENOMEM;
	351	dev->mode_config.gamma_lut_property = prop;
	352
	353	prop = drm_property_create_range(dev,
	354	DRM_MODE_PROP_IMMUTABLE,
	355	"GAMMA_LUT_SIZE", 0, UINT_MAX);
	356	if (!prop)
	357	return -ENOMEM;
	358	dev->mode_config.gamma_lut_size_property = prop;
	359
db1689aa BW	360	prop = drm_property_create(dev,
	361	DRM_MODE_PROP_IMMUTABLE \| DRM_MODE_PROP_BLOB,
	362	"IN_FORMATS", 0);
	363	if (!prop)
	364	return -ENOMEM;
	365	dev->mode_config.modifiers_property = prop;
	366
28575f16 DV	367	return 0;
	368	}
	369
	370	/**
	371	* drm_mode_config_init - initialize DRM mode_configuration structure
	372	* @dev: DRM device
	373	*
	374	* Initialize @dev's mode_config structure, used for tracking the graphics
	375	* configuration of @dev.
	376	*
	377	* Since this initializes the modeset locks, no locking is possible. Which is no
	378	* problem, since this should happen single threaded at init time. It is the
	379	* driver's problem to ensure this guarantee.
	380	*
	381	*/
	382	void drm_mode_config_init(struct drm_device *dev)
	383	{
	384	mutex_init(&dev->mode_config.mutex);
	385	drm_modeset_lock_init(&dev->mode_config.connection_mutex);
	386	mutex_init(&dev->mode_config.idr_mutex);
	387	mutex_init(&dev->mode_config.fb_lock);
	388	mutex_init(&dev->mode_config.blob_lock);
	389	INIT_LIST_HEAD(&dev->mode_config.fb_list);
	390	INIT_LIST_HEAD(&dev->mode_config.crtc_list);
	391	INIT_LIST_HEAD(&dev->mode_config.connector_list);
	392	INIT_LIST_HEAD(&dev->mode_config.encoder_list);
	393	INIT_LIST_HEAD(&dev->mode_config.property_list);
	394	INIT_LIST_HEAD(&dev->mode_config.property_blob_list);
	395	INIT_LIST_HEAD(&dev->mode_config.plane_list);
	396	idr_init(&dev->mode_config.crtc_idr);
	397	idr_init(&dev->mode_config.tile_idr);
	398	ida_init(&dev->mode_config.connector_ida);
613051da	399	spin_lock_init(&dev->mode_config.connector_list_lock);
28575f16	400
ea497bb9 DV	401	init_llist_head(&dev->mode_config.connector_free_list);
	402	INIT_WORK(&dev->mode_config.connector_free_work, drm_connector_free_work_fn);
	403
28575f16	404	drm_mode_create_standard_properties(dev);
28575f16 DV	405
	406	/* Just to be sure */
	407	dev->mode_config.num_fb = 0;
	408	dev->mode_config.num_connector = 0;
	409	dev->mode_config.num_crtc = 0;
	410	dev->mode_config.num_encoder = 0;
28575f16 DV	411	dev->mode_config.num_total_plane = 0;
	412	}
	413	EXPORT_SYMBOL(drm_mode_config_init);
	414
	415	/**
	416	* drm_mode_config_cleanup - free up DRM mode_config info
	417	* @dev: DRM device
	418	*
	419	* Free up all the connectors and CRTCs associated with this DRM device, then
	420	* free up the framebuffers and associated buffer objects.
	421	*
	422	* Note that since this /should/ happen single-threaded at driver/device
	423	* teardown time, no locking is required. It's the driver's job to ensure that
	424	* this guarantee actually holds true.
	425	*
	426	* FIXME: cleanup any dangling user buffer objects too
	427	*/
	428	void drm_mode_config_cleanup(struct drm_device *dev)
	429	{
2ab8c5f8 DV	430	struct drm_connector *connector;
2ab8c5f8 DV	431	struct drm_connector_list_iter conn_iter;
28575f16 DV	432	struct drm_crtc crtc, ct;
	433	struct drm_encoder encoder, enct;
	434	struct drm_framebuffer fb, fbt;
	435	struct drm_property property, pt;
	436	struct drm_property_blob blob, bt;
	437	struct drm_plane plane, plt;
	438
	439	list_for_each_entry_safe(encoder, enct, &dev->mode_config.encoder_list,
	440	head) {
	441	encoder->funcs->destroy(encoder);
	442	}
	443
b982dab1	444	drm_connector_list_iter_begin(dev, &conn_iter);
2ab8c5f8 DV	445	drm_for_each_connector_iter(connector, &conn_iter) {
	446	/* drm_connector_list_iter holds an full reference to the
	447	* current connector itself, which means it is inherently safe
	448	* against unreferencing the current connector - but not against
	449	* deleting it right away. */
ad093607	450	drm_connector_put(connector);
28575f16	451	}
b982dab1	452	drm_connector_list_iter_end(&conn_iter);
a703c550	453	/* connector_iter drops references in a work item. */
ea497bb9	454	flush_work(&dev->mode_config.connector_free_work);
d352f352	455	if (WARN_ON(!list_empty(&dev->mode_config.connector_list))) {
b982dab1	456	drm_connector_list_iter_begin(dev, &conn_iter);
d352f352 CW	457	drm_for_each_connector_iter(connector, &conn_iter)
d352f352 CW	458	DRM_ERROR("connector %s leaked!\n", connector->name);
b982dab1	459	drm_connector_list_iter_end(&conn_iter);
d352f352	460	}
28575f16 DV	461
	462	list_for_each_entry_safe(property, pt, &dev->mode_config.property_list,
	463	head) {
	464	drm_property_destroy(dev, property);
	465	}
	466
	467	list_for_each_entry_safe(plane, plt, &dev->mode_config.plane_list,
	468	head) {
	469	plane->funcs->destroy(plane);
	470	}
	471
	472	list_for_each_entry_safe(crtc, ct, &dev->mode_config.crtc_list, head) {
	473	crtc->funcs->destroy(crtc);
	474	}
	475
	476	list_for_each_entry_safe(blob, bt, &dev->mode_config.property_blob_list,
	477	head_global) {
6472e509	478	drm_property_blob_put(blob);
28575f16 DV	479	}
	480
	481	/*
	482	* Single-threaded teardown context, so it's not required to grab the
	483	* fb_lock to protect against concurrent fb_list access. Contrary, it
	484	* would actually deadlock with the drm_framebuffer_cleanup function.
	485	*
	486	* Also, if there are any framebuffers left, that's a driver leak now,
	487	* so politely WARN about this.
	488	*/
	489	WARN_ON(!list_empty(&dev->mode_config.fb_list));
	490	list_for_each_entry_safe(fb, fbt, &dev->mode_config.fb_list, head) {
2aa0fcc2 DV	491	struct drm_printer p = drm_debug_printer("[leaked fb]");
	492	drm_printf(&p, "framebuffer[%u]:\n", fb->base.id);
	493	drm_framebuffer_print_info(&p, 1, fb);
28575f16 DV	494	drm_framebuffer_free(&fb->base.refcount);
	495	}
	496
	497	ida_destroy(&dev->mode_config.connector_ida);
	498	idr_destroy(&dev->mode_config.tile_idr);
	499	idr_destroy(&dev->mode_config.crtc_idr);
	500	drm_modeset_lock_fini(&dev->mode_config.connection_mutex);
	501	}
	502	EXPORT_SYMBOL(drm_mode_config_cleanup);