Merge tag 'topic/drm-misc-2015-05-19' of git://anongit.freedesktop.org/drm-intel into drm-next (9c37bf2d) · Commits · 戴 / test

drivers/gpu/drm/Makefile

+0 −2

Original line number	Diff line number	Diff line
		@@ -2,8 +2,6 @@
		# Makefile for the drm device driver. This driver provides support for the
		# Direct Rendering Infrastructure (DRI) in XFree86 4.1.0 and higher.

		ccflags-y := -Iinclude/drm

		drm-y := drm_auth.o drm_bufs.o drm_cache.o \
		drm_context.o drm_dma.o \
		drm_fops.o drm_gem.o drm_ioctl.o drm_irq.o \

drivers/gpu/drm/drm_atomic.c

+96 −38

Original line number	Diff line number	Diff line
		@@ -30,7 +30,15 @@
		#include <drm/drm_atomic.h>
		#include <drm/drm_plane_helper.h>

		static void kfree_state(struct drm_atomic_state *state)
		/**
		* drm_atomic_state_default_release -
		* release memory initialized by drm_atomic_state_init
		* @state: atomic state
		*
		* Free all the memory allocated by drm_atomic_state_init.
		* This is useful for drivers that subclass the atomic state.
		*/
		void drm_atomic_state_default_release(struct drm_atomic_state *state)
		{
		kfree(state->connectors);
		kfree(state->connector_states);
		@@ -38,24 +46,20 @@ static void kfree_state(struct drm_atomic_state *state)
		kfree(state->crtc_states);
		kfree(state->planes);
		kfree(state->plane_states);
		kfree(state);
		}
		EXPORT_SYMBOL(drm_atomic_state_default_release);

		/**
		* drm_atomic_state_alloc - allocate atomic state
		* drm_atomic_state_init - init new atomic state
		* @dev: DRM device
		* @state: atomic state
		*
		* This allocates an empty atomic state to track updates.
		* Default implementation for filling in a new atomic state.
		* This is useful for drivers that subclass the atomic state.
		*/
		struct drm_atomic_state *
		drm_atomic_state_alloc(struct drm_device *dev)
		int
		drm_atomic_state_init(struct drm_device dev, struct drm_atomic_state state)
		{
		struct drm_atomic_state *state;

		state = kzalloc(sizeof(*state), GFP_KERNEL);
		if (!state)
		return NULL;

		/* TODO legacy paths should maybe do a better job about
		* setting this appropriately?
		*/
		@@ -92,31 +96,50 @@ drm_atomic_state_alloc(struct drm_device *dev)

		state->dev = dev;

		DRM_DEBUG_ATOMIC("Allocate atomic state %p\n", state);
		DRM_DEBUG_ATOMIC("Allocated atomic state %p\n", state);

		return state;
		return 0;
		fail:
		kfree_state(state);
		drm_atomic_state_default_release(state);
		return -ENOMEM;
		}
		EXPORT_SYMBOL(drm_atomic_state_init);

		/**
		* drm_atomic_state_alloc - allocate atomic state
		* @dev: DRM device
		*
		* This allocates an empty atomic state to track updates.
		*/
		struct drm_atomic_state *
		drm_atomic_state_alloc(struct drm_device *dev)
		{
		struct drm_mode_config *config = &dev->mode_config;
		struct drm_atomic_state *state;

		if (!config->funcs->atomic_state_alloc) {
		state = kzalloc(sizeof(*state), GFP_KERNEL);
		if (!state)
		return NULL;
		if (drm_atomic_state_init(dev, state) < 0) {
		kfree(state);
		return NULL;
		}
		return state;
		}

		return config->funcs->atomic_state_alloc(dev);
		}
		EXPORT_SYMBOL(drm_atomic_state_alloc);

		/**
		* drm_atomic_state_clear - clear state object
		* drm_atomic_state_default_clear - clear base atomic state
		* @state: atomic state
		*
		* When the w/w mutex algorithm detects a deadlock we need to back off and drop
		* all locks. So someone else could sneak in and change the current modeset
		* configuration. Which means that all the state assembled in @state is no
		* longer an atomic update to the current state, but to some arbitrary earlier
		* state. Which could break assumptions the driver's ->atomic_check likely
		* relies on.
		*
		* Hence we must clear all cached state and completely start over, using this
		* function.
		* Default implementation for clearing atomic state.
		* This is useful for drivers that subclass the atomic state.
		*/
		void drm_atomic_state_clear(struct drm_atomic_state *state)
		void drm_atomic_state_default_clear(struct drm_atomic_state *state)
		{
		struct drm_device *dev = state->dev;
		struct drm_mode_config *config = &dev->mode_config;
		@@ -162,6 +185,32 @@ void drm_atomic_state_clear(struct drm_atomic_state *state)
		state->plane_states[i] = NULL;
		}
		}
		EXPORT_SYMBOL(drm_atomic_state_default_clear);

		/**
		* drm_atomic_state_clear - clear state object
		* @state: atomic state
		*
		* When the w/w mutex algorithm detects a deadlock we need to back off and drop
		* all locks. So someone else could sneak in and change the current modeset
		* configuration. Which means that all the state assembled in @state is no
		* longer an atomic update to the current state, but to some arbitrary earlier
		* state. Which could break assumptions the driver's ->atomic_check likely
		* relies on.
		*
		* Hence we must clear all cached state and completely start over, using this
		* function.
		*/
		void drm_atomic_state_clear(struct drm_atomic_state *state)
		{
		struct drm_device *dev = state->dev;
		struct drm_mode_config *config = &dev->mode_config;

		if (config->funcs->atomic_state_clear)
		config->funcs->atomic_state_clear(state);
		else
		drm_atomic_state_default_clear(state);
		}
		EXPORT_SYMBOL(drm_atomic_state_clear);

		/**
		@@ -173,14 +222,25 @@ EXPORT_SYMBOL(drm_atomic_state_clear);
		*/
		void drm_atomic_state_free(struct drm_atomic_state *state)
		{
		struct drm_device *dev;
		struct drm_mode_config *config;

		if (!state)
		return;

		dev = state->dev;
		config = &dev->mode_config;

		drm_atomic_state_clear(state);

		DRM_DEBUG_ATOMIC("Freeing atomic state %p\n", state);

		kfree_state(state);
		if (config->funcs->atomic_state_free) {
		config->funcs->atomic_state_free(state);
		} else {
		drm_atomic_state_default_release(state);
		kfree(state);
		}
		}
		EXPORT_SYMBOL(drm_atomic_state_free);

		@@ -203,13 +263,12 @@ struct drm_crtc_state *
		drm_atomic_get_crtc_state(struct drm_atomic_state *state,
		struct drm_crtc *crtc)
		{
		int ret, index;
		int ret, index = drm_crtc_index(crtc);
		struct drm_crtc_state *crtc_state;

		index = drm_crtc_index(crtc);

		if (state->crtc_states[index])
		return state->crtc_states[index];
		crtc_state = drm_atomic_get_existing_crtc_state(state, crtc);
		if (crtc_state)
		return crtc_state;

		ret = drm_modeset_lock(&crtc->mutex, state->acquire_ctx);
		if (ret)
		@@ -337,13 +396,12 @@ struct drm_plane_state *
		drm_atomic_get_plane_state(struct drm_atomic_state *state,
		struct drm_plane *plane)
		{
		int ret, index;
		int ret, index = drm_plane_index(plane);
		struct drm_plane_state *plane_state;

		index = drm_plane_index(plane);

		if (state->plane_states[index])
		return state->plane_states[index];
		plane_state = drm_atomic_get_existing_plane_state(state, plane);
		if (plane_state)
		return plane_state;

		ret = drm_modeset_lock(&plane->mutex, state->acquire_ctx);
		if (ret)

drivers/gpu/drm/drm_atomic_helper.c

+24 −5

Original line number	Diff line number	Diff line
		@@ -624,8 +624,22 @@ disable_outputs(struct drm_device dev, struct drm_atomic_state old_state)
		}
		}

		static void
		set_routing_links(struct drm_device dev, struct drm_atomic_state old_state)
		/**
		* drm_atomic_helper_update_legacy_modeset_state - update legacy modeset state
		* @dev: DRM device
		* @old_state: atomic state object with old state structures
		*
		* This function updates all the various legacy modeset state pointers in
		* connectors, encoders and crtcs. It also updates the timestamping constants
		* used for precise vblank timestamps by calling
		* drm_calc_timestamping_constants().
		*
		* Drivers can use this for building their own atomic commit if they don't have
		* a pure helper-based modeset implementation.
		*/
		void
		drm_atomic_helper_update_legacy_modeset_state(struct drm_device *dev,
		struct drm_atomic_state *old_state)
		{
		struct drm_connector *connector;
		struct drm_connector_state *old_conn_state;
		@@ -662,8 +676,13 @@ set_routing_links(struct drm_device dev, struct drm_atomic_state old_state)
		crtc->enabled = crtc->state->enable;
		crtc->x = crtc->primary->state->src_x >> 16;
		crtc->y = crtc->primary->state->src_y >> 16;

		if (crtc->state->enable)
		drm_calc_timestamping_constants(crtc,
		&crtc->state->adjusted_mode);
		}
		}
		EXPORT_SYMBOL(drm_atomic_helper_update_legacy_modeset_state);

		static void
		crtc_set_mode(struct drm_device dev, struct drm_atomic_state old_state)
		@@ -742,7 +761,9 @@ void drm_atomic_helper_commit_modeset_disables(struct drm_device *dev,
		struct drm_atomic_state *old_state)
		{
		disable_outputs(dev, old_state);
		set_routing_links(dev, old_state);

		drm_atomic_helper_update_legacy_modeset_state(dev, old_state);

		crtc_set_mode(dev, old_state);
		}
		EXPORT_SYMBOL(drm_atomic_helper_commit_modeset_disables);
		@@ -1135,8 +1156,6 @@ void drm_atomic_helper_commit_planes(struct drm_device *dev,
		if (!funcs)
		continue;

		old_plane_state = old_state->plane_states[i];

		/*
		* Special-case disabling the plane if drivers support it.
		*/

drivers/gpu/drm/drm_crtc.c

+266 −59

Original line number	Diff line number	Diff line
		@@ -352,7 +352,9 @@ static struct drm_mode_object _object_find(struct drm_device dev,
		if (obj && obj->id != id)
		obj = NULL;
		/* don't leak out unref'd fb's */
		if (obj && (obj->type == DRM_MODE_OBJECT_FB))
		if (obj &&
		(obj->type == DRM_MODE_OBJECT_FB \|\|
		obj->type == DRM_MODE_OBJECT_BLOB))
		obj = NULL;
		mutex_unlock(&dev->mode_config.idr_mutex);

		@@ -377,7 +379,7 @@ struct drm_mode_object drm_mode_object_find(struct drm_device dev,

		/* Framebuffers are reference counted and need their own lookup
		* function.*/
		WARN_ON(type == DRM_MODE_OBJECT_FB);
		WARN_ON(type == DRM_MODE_OBJECT_FB \|\| type == DRM_MODE_OBJECT_BLOB);
		obj = _object_find(dev, id, type);
		return obj;
		}
		@@ -4225,7 +4227,7 @@ done:
		return ret;
		}

		static struct drm_property_blob *
		struct drm_property_blob *
		drm_property_create_blob(struct drm_device *dev, size_t length,
		const void *data)
		{
		@@ -4239,28 +4241,237 @@ drm_property_create_blob(struct drm_device *dev, size_t length,
		if (!blob)
		return NULL;

		blob->length = length;
		blob->dev = dev;

		memcpy(blob->data, data, length);

		mutex_lock(&dev->mode_config.blob_lock);

		ret = drm_mode_object_get(dev, &blob->base, DRM_MODE_OBJECT_BLOB);
		if (ret) {
		kfree(blob);
		mutex_unlock(&dev->mode_config.blob_lock);
		return NULL;
		}

		blob->length = length;

		memcpy(blob->data, data, length);
		kref_init(&blob->refcount);

		list_add_tail(&blob->head, &dev->mode_config.property_blob_list);

		mutex_unlock(&dev->mode_config.blob_lock);

		return blob;
		}
		EXPORT_SYMBOL(drm_property_create_blob);

		static void drm_property_destroy_blob(struct drm_device *dev,
		struct drm_property_blob *blob)
		/**
		* drm_property_free_blob - Blob property destructor
		*
		* Internal free function for blob properties; must not be used directly.
		*
		* @param kref Reference
		*/
		static void drm_property_free_blob(struct kref *kref)
		{
		drm_mode_object_put(dev, &blob->base);
		struct drm_property_blob *blob =
		container_of(kref, struct drm_property_blob, refcount);

		WARN_ON(!mutex_is_locked(&blob->dev->mode_config.blob_lock));

		list_del(&blob->head);
		drm_mode_object_put(blob->dev, &blob->base);

		kfree(blob);
		}

		/**
		* drm_property_unreference_blob - Unreference a blob property
		*
		* Drop a reference on a blob property. May free the object.
		*
		* @param blob Pointer to blob property
		*/
		void drm_property_unreference_blob(struct drm_property_blob *blob)
		{
		struct drm_device *dev;

		if (!blob)
		return;

		dev = blob->dev;

		DRM_DEBUG("%p: blob ID: %d (%d)\n", blob, blob->base.id, atomic_read(&blob->refcount.refcount));

		if (kref_put_mutex(&blob->refcount, drm_property_free_blob,
		&dev->mode_config.blob_lock))
		mutex_unlock(&dev->mode_config.blob_lock);
		else
		might_lock(&dev->mode_config.blob_lock);

		}
		EXPORT_SYMBOL(drm_property_unreference_blob);

		/**
		* drm_property_unreference_blob_locked - Unreference a blob property with blob_lock held
		*
		* Drop a reference on a blob property. May free the object. This must be
		* called with blob_lock held.
		*
		* @param dev Device the blob was created on
		* @param blob Pointer to blob property
		*/
		static void drm_property_unreference_blob_locked(struct drm_property_blob *blob)
		{
		if (!blob)
		return;

		DRM_DEBUG("%p: blob ID: %d (%d)\n", blob, blob->base.id, atomic_read(&blob->refcount.refcount));

		kref_put(&blob->refcount, drm_property_free_blob);
		}

		/**
		* drm_property_reference_blob - Take a reference on an existing property
		*
		* Take a new reference on an existing blob property.
		*
		* @param blob Pointer to blob property
		*/
		struct drm_property_blob drm_property_reference_blob(struct drm_property_blob blob)
		{
		DRM_DEBUG("%p: blob ID: %d (%d)\n", blob, blob->base.id, atomic_read(&blob->refcount.refcount));
		kref_get(&blob->refcount);
		return blob;
		}
		EXPORT_SYMBOL(drm_property_reference_blob);

		/*
		* Like drm_property_lookup_blob, but does not return an additional reference.
		* Must be called with blob_lock held.
		*/
		static struct drm_property_blob __drm_property_lookup_blob(struct drm_device dev,
		uint32_t id)
		{
		struct drm_mode_object *obj = NULL;
		struct drm_property_blob *blob;

		WARN_ON(!mutex_is_locked(&dev->mode_config.blob_lock));

		mutex_lock(&dev->mode_config.idr_mutex);
		obj = idr_find(&dev->mode_config.crtc_idr, id);
		if (!obj \|\| (obj->type != DRM_MODE_OBJECT_BLOB) \|\| (obj->id != id))
		blob = NULL;
		else
		blob = obj_to_blob(obj);
		mutex_unlock(&dev->mode_config.idr_mutex);

		return blob;
		}

		/**
		* drm_property_lookup_blob - look up a blob property and take a reference
		* @dev: drm device
		* @id: id of the blob property
		*
		* If successful, this takes an additional reference to the blob property.
		* callers need to make sure to eventually unreference the returned property
		* again, using @drm_property_unreference_blob.
		*/
		struct drm_property_blob drm_property_lookup_blob(struct drm_device dev,
		uint32_t id)
		{
		struct drm_property_blob *blob;

		mutex_lock(&dev->mode_config.blob_lock);
		blob = __drm_property_lookup_blob(dev, id);
		if (blob) {
		if (!kref_get_unless_zero(&blob->refcount))
		blob = NULL;
		}
		mutex_unlock(&dev->mode_config.blob_lock);

		return blob;
		}
		EXPORT_SYMBOL(drm_property_lookup_blob);

		/**
		* drm_property_replace_global_blob - atomically replace existing blob property
		* @dev: drm device
		* @replace: location of blob property pointer to be replaced
		* @length: length of data for new blob, or 0 for no data
		* @data: content for new blob, or NULL for no data
		* @obj_holds_id: optional object for property holding blob ID
		* @prop_holds_id: optional property holding blob ID
		* @return 0 on success or error on failure
		*
		* This function will atomically replace a global property in the blob list,
		* optionally updating a property which holds the ID of that property. It is
		* guaranteed to be atomic: no caller will be allowed to see intermediate
		* results, and either the entire operation will succeed and clean up the
		* previous property, or it will fail and the state will be unchanged.
		*
		* If length is 0 or data is NULL, no new blob will be created, and the holding
		* property, if specified, will be set to 0.
		*
		* Access to the replace pointer is assumed to be protected by the caller, e.g.
		* by holding the relevant modesetting object lock for its parent.
		*
		* For example, a drm_connector has a 'PATH' property, which contains the ID
		* of a blob property with the value of the MST path information. Calling this
		* function with replace pointing to the connector's path_blob_ptr, length and
		* data set for the new path information, obj_holds_id set to the connector's
		* base object, and prop_holds_id set to the path property name, will perform
		* a completely atomic update. The access to path_blob_ptr is protected by the
		* caller holding a lock on the connector.
		*/
		static int drm_property_replace_global_blob(struct drm_device *dev,
		struct drm_property_blob **replace,
		size_t length,
		const void *data,
		struct drm_mode_object *obj_holds_id,
		struct drm_property *prop_holds_id)
		{
		struct drm_property_blob *new_blob = NULL;
		struct drm_property_blob *old_blob = NULL;
		int ret;

		WARN_ON(replace == NULL);

		old_blob = *replace;

		if (length && data) {
		new_blob = drm_property_create_blob(dev, length, data);
		if (!new_blob)
		return -EINVAL;
		}

		/* This does not need to be synchronised with blob_lock, as the
		* get_properties ioctl locks all modesetting objects, and
		* obj_holds_id must be locked before calling here, so we cannot
		* have its value out of sync with the list membership modified
		* below under blob_lock. */
		if (obj_holds_id) {
		ret = drm_object_property_set_value(obj_holds_id,
		prop_holds_id,
		new_blob ?
		new_blob->base.id : 0);
		if (ret != 0)
		goto err_created;
		}

		if (old_blob)
		drm_property_unreference_blob(old_blob);

		*replace = new_blob;

		return 0;

		err_created:
		drm_property_unreference_blob(new_blob);
		return ret;
		}

		/**
		* drm_mode_getblob_ioctl - get the contents of a blob property value
		* @dev: DRM device
		@@ -4287,7 +4498,8 @@ int drm_mode_getblob_ioctl(struct drm_device *dev,
		return -EINVAL;

		drm_modeset_lock_all(dev);
		blob = drm_property_blob_find(dev, out_resp->blob_id);
		mutex_lock(&dev->mode_config.blob_lock);
		blob = __drm_property_lookup_blob(dev, out_resp->blob_id);
		if (!blob) {
		ret = -ENOENT;
		goto done;
		@@ -4303,6 +4515,7 @@ int drm_mode_getblob_ioctl(struct drm_device *dev,
		out_resp->length = blob->length;

		done:
		mutex_unlock(&dev->mode_config.blob_lock);
		drm_modeset_unlock_all(dev);
		return ret;
		}
		@@ -4310,7 +4523,7 @@ done:
		/**
		* drm_mode_connector_set_path_property - set tile property on connector
		* @connector: connector to set property on.
		* @path: path to use for property.
		* @path: path to use for property; must not be NULL.
		*
		* This creates a property to expose to userspace to specify a
		* connector path. This is mainly used for DisplayPort MST where
		@@ -4324,17 +4537,14 @@ int drm_mode_connector_set_path_property(struct drm_connector *connector,
		const char *path)
		{
		struct drm_device *dev = connector->dev;
		size_t size = strlen(path) + 1;
		int ret;

		connector->path_blob_ptr = drm_property_create_blob(connector->dev,
		size, path);
		if (!connector->path_blob_ptr)
		return -EINVAL;

		ret = drm_object_property_set_value(&connector->base,
		dev->mode_config.path_property,
		connector->path_blob_ptr->base.id);
		ret = drm_property_replace_global_blob(dev,
		&connector->path_blob_ptr,
		strlen(path) + 1,
		path,
		&connector->base,
		dev->mode_config.path_property);
		return ret;
		}
		EXPORT_SYMBOL(drm_mode_connector_set_path_property);
		@@ -4353,16 +4563,16 @@ EXPORT_SYMBOL(drm_mode_connector_set_path_property);
		int drm_mode_connector_set_tile_property(struct drm_connector *connector)
		{
		struct drm_device *dev = connector->dev;
		int ret, size;
		char tile[256];

		if (connector->tile_blob_ptr)
		drm_property_destroy_blob(dev, connector->tile_blob_ptr);
		int ret;

		if (!connector->has_tile) {
		connector->tile_blob_ptr = NULL;
		ret = drm_object_property_set_value(&connector->base,
		dev->mode_config.tile_property, 0);
		ret = drm_property_replace_global_blob(dev,
		&connector->tile_blob_ptr,
		0,
		NULL,
		&connector->base,
		dev->mode_config.tile_property);
		return ret;
		}

		@@ -4371,16 +4581,13 @@ int drm_mode_connector_set_tile_property(struct drm_connector *connector)
		connector->num_h_tile, connector->num_v_tile,
		connector->tile_h_loc, connector->tile_v_loc,
		connector->tile_h_size, connector->tile_v_size);
		size = strlen(tile) + 1;

		connector->tile_blob_ptr = drm_property_create_blob(connector->dev,
		size, tile);
		if (!connector->tile_blob_ptr)
		return -EINVAL;

		ret = drm_object_property_set_value(&connector->base,
		dev->mode_config.tile_property,
		connector->tile_blob_ptr->base.id);
		ret = drm_property_replace_global_blob(dev,
		&connector->tile_blob_ptr,
		strlen(tile) + 1,
		tile,
		&connector->base,
		dev->mode_config.tile_property);
		return ret;
		}
		EXPORT_SYMBOL(drm_mode_connector_set_tile_property);
		@@ -4400,33 +4607,22 @@ int drm_mode_connector_update_edid_property(struct drm_connector *connector,
		const struct edid *edid)
		{
		struct drm_device *dev = connector->dev;
		size_t size;
		size_t size = 0;
		int ret;

		/* ignore requests to set edid when overridden */
		if (connector->override_edid)
		return 0;

		if (connector->edid_blob_ptr)
		drm_property_destroy_blob(dev, connector->edid_blob_ptr);

		/* Delete edid, when there is none. */
		if (!edid) {
		connector->edid_blob_ptr = NULL;
		ret = drm_object_property_set_value(&connector->base, dev->mode_config.edid_property, 0);
		return ret;
		}

		size = EDID_LENGTH * (1 + edid->extensions);
		connector->edid_blob_ptr = drm_property_create_blob(connector->dev,
		size, edid);
		if (!connector->edid_blob_ptr)
		return -EINVAL;

		ret = drm_object_property_set_value(&connector->base,
		dev->mode_config.edid_property,
		connector->edid_blob_ptr->base.id);
		if (edid)
		size = EDID_LENGTH + (1 + edid->extensions);

		ret = drm_property_replace_global_blob(dev,
		&connector->edid_blob_ptr,
		size,
		edid,
		&connector->base,
		dev->mode_config.edid_property);
		return ret;
		}
		EXPORT_SYMBOL(drm_mode_connector_update_edid_property);
		@@ -4467,8 +4663,18 @@ bool drm_property_change_valid_get(struct drm_property *property,
		valid_mask \|= (1ULL << property->values[i]);
		return !(value & ~valid_mask);
		} else if (drm_property_type_is(property, DRM_MODE_PROP_BLOB)) {
		/* Only the driver knows */
		struct drm_property_blob *blob;

		if (value == 0)
		return true;

		blob = drm_property_lookup_blob(property->dev, value);
		if (blob) {
		*ref = &blob->base;
		return true;
		} else {
		return false;
		}
		} else if (drm_property_type_is(property, DRM_MODE_PROP_OBJECT)) {
		/* a zero value for an object property translates to null: */
		if (value == 0)
		@@ -5453,6 +5659,7 @@ void drm_mode_config_init(struct drm_device *dev)
		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);
		@@ -5517,7 +5724,7 @@ void drm_mode_config_cleanup(struct drm_device *dev)

		list_for_each_entry_safe(blob, bt, &dev->mode_config.property_blob_list,
		head) {
		drm_property_destroy_blob(dev, blob);
		drm_property_unreference_blob(blob);
		}

		/*

drivers/gpu/drm/drm_crtc_helper.c

+6 −1

Original line number	Diff line number	Diff line
		@@ -959,7 +959,12 @@ int drm_helper_crtc_mode_set(struct drm_crtc crtc, struct drm_display_mode mod
		if (crtc_funcs->atomic_check) {
		ret = crtc_funcs->atomic_check(crtc, crtc_state);
		if (ret) {
		if (crtc->funcs->atomic_destroy_state) {
		crtc->funcs->atomic_destroy_state(crtc,
		crtc_state);
		} else {
		kfree(crtc_state);
		}

		return ret;
		}

Admin message