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

 #include
 #include
 #include
+#include "drm_crtc_internal.h"
-#include "drm_crtc_internal.h"
+#include "drm_internal.h"
 static struct drm_framebuffer *add_framebuffer_internal(struct drm_device *dev,
-							struct drm_mode_fb_cmd2 *r,
-							struct drm_file *file_priv);
-/**
- * drm_modeset_lock_all - take all modeset locks
- * @dev: drm device
- *
- * This function takes all modeset locks, suitable where a more fine-grained
- * scheme isn't (yet) implemented. Locks must be dropped with
- * drm_modeset_unlock_all.
- */
-void drm_modeset_lock_all(struct drm_device *dev)
-{
-	struct drm_mode_config *config = &dev->mode_config;
-	struct drm_modeset_acquire_ctx *ctx;
-	int ret;
-	ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
-	if (WARN_ON(!ctx))
-		return;
-	mutex_lock(&config->mutex);
-	drm_modeset_acquire_init(ctx, 0);
-retry:
-	ret = drm_modeset_lock(&config->connection_mutex, ctx);
-	if (ret)
-		goto fail;
-	ret = drm_modeset_lock_all_crtcs(dev, ctx);
-	if (ret)
-		goto fail;
-	WARN_ON(config->acquire_ctx);
-	/* now we hold the locks, so now that it is safe, stash the
-	 * ctx for drm_modeset_unlock_all():
-	 */
-	config->acquire_ctx = ctx;
-	drm_warn_on_modeset_not_all_locked(dev);
-	return;
-fail:
-	if (ret == -EDEADLK) {
-		drm_modeset_backoff(ctx);
-		goto retry;
-	}
-}
-EXPORT_SYMBOL(drm_modeset_lock_all);
-/**
- * drm_modeset_unlock_all - drop all modeset locks
- * @dev: device
- *
- * This function drop all modeset locks taken by drm_modeset_lock_all.
- */
-void drm_modeset_unlock_all(struct drm_device *dev)
-{
-	struct drm_mode_config *config = &dev->mode_config;
-	struct drm_modeset_acquire_ctx *ctx = config->acquire_ctx;
-	if (WARN_ON(!ctx))
-		return;
-	config->acquire_ctx = NULL;
-	drm_modeset_drop_locks(ctx);
-	drm_modeset_acquire_fini(ctx);
-	kfree(ctx);
-	mutex_unlock(&dev->mode_config.mutex);
-}
-EXPORT_SYMBOL(drm_modeset_unlock_all);
-/**
- * drm_warn_on_modeset_not_all_locked - check that all modeset locks are locked
- * @dev: device
- *
- * Useful as a debug assert.
- */
-void drm_warn_on_modeset_not_all_locked(struct drm_device *dev)
-{
-	struct drm_crtc *crtc;
-	list_for_each_entry(crtc, &dev->mode_config.crtc_list, head)
-		WARN_ON(!drm_modeset_is_locked(&crtc->mutex));
-	WARN_ON(!drm_modeset_is_locked(&dev->mode_config.connection_mutex));
-	WARN_ON(!mutex_is_locked(&dev->mode_config.mutex));
 							struct drm_mode_fb_cmd2 *r,
-EXPORT_SYMBOL(drm_warn_on_modeset_not_all_locked);
+							struct drm_file *file_priv);
 /* Avoid boilerplate.  I'm tired of typing. */
 #define DRM_ENUM_NAME_FN(fnname, list)				\
 	ret = drm_mode_object_get(dev, &fb->base, DRM_MODE_OBJECT_FB);
 	if (ret)
-		goto out;
-	/* Grab the idr reference. */
-	drm_framebuffer_reference(fb);
+		goto out;
 	dev->mode_config.num_fb++;
 	list_add(&fb->head, &dev->mode_config.fb_list);
 out:
 	mutex_unlock(&dev->mode_config.fb_lock);
+	return 0;
+}
+EXPORT_SYMBOL(drm_framebuffer_init);
+/* dev->mode_config.fb_lock must be held! */
+static void __drm_framebuffer_unregister(struct drm_device *dev,
+					 struct drm_framebuffer *fb)
+{
+	mutex_lock(&dev->mode_config.idr_mutex);
+	idr_remove(&dev->mode_config.crtc_idr, fb->base.id);
+	mutex_unlock(&dev->mode_config.idr_mutex);
 	return 0;
 	fb->base.id = 0;
 EXPORT_SYMBOL(drm_framebuffer_init);
+static void drm_framebuffer_free(struct kref *kref)
+{
+	struct drm_framebuffer *fb =
+			container_of(kref, struct drm_framebuffer, refcount);
+	struct drm_device *dev = fb->dev;
+	/*
+	 * The lookup idr holds a weak reference, which has not necessarily been
+	 * removed at this point. Check for that.
+	 */
+	mutex_lock(&dev->mode_config.fb_lock);
+	if (fb->base.id) {
+		/* Mark fb as reaped and drop idr ref. */
-static void drm_framebuffer_free(struct kref *kref)
+		__drm_framebuffer_unregister(dev, fb);
+	}
-	struct drm_framebuffer *fb =
+	mutex_unlock(&dev->mode_config.fb_lock);
 			container_of(kref, struct drm_framebuffer, refcount);
+{
 	DRM_DEBUG("%p: FB ID: %d (%d)\n", fb, fb->base.id, atomic_read(&fb->refcount.refcount));
 	kref_put(&fb->refcount, drm_framebuffer_free_bug);
+}
-/* dev->mode_config.fb_lock must be held! */
-static void __drm_framebuffer_unregister(struct drm_device *dev,
-					 struct drm_framebuffer *fb)
-{
-	mutex_lock(&dev->mode_config.idr_mutex);
-	idr_remove(&dev->mode_config.crtc_idr, fb->base.id);
-	mutex_unlock(&dev->mode_config.idr_mutex);
-	fb->base.id = 0;
-	__drm_framebuffer_unreference(fb);
-}
 /**
  * drm_framebuffer_unregister_private - unregister a private fb from the lookup idr
  * @fb: fb to unregister
+ *
 	crtc->dev = dev;
 	crtc->funcs = funcs;
-	crtc->invert_dimensions = false;
 	crtc->invert_dimensions = false;
-	drm_modeset_lock_all(dev);
-	drm_modeset_lock_init(&crtc->mutex);
-	/* dropped by _unlock_all(): */
 	drm_modeset_lock(&crtc->mutex, config->acquire_ctx);
 	drm_modeset_lock_init(&crtc->mutex);
 	ret = drm_mode_object_get(dev, &crtc->base, DRM_MODE_OBJECT_CRTC);
 	if (ret)
-		goto out;
+		return ret;
 	if (primary)
 		primary->possible_crtcs = 1 << drm_crtc_index(crtc);
 	if (cursor)
 		cursor->possible_crtcs = 1 << drm_crtc_index(crtc);
- out:
-	drm_modeset_unlock_all(dev);
-	return ret;
+	return 0;
+}
 EXPORT_SYMBOL(drm_crtc_init_with_planes);
 	drm_modeset_lock_fini(&crtc->mutex);
 	drm_mode_object_put(dev, &crtc->base);
 	list_del(&crtc->head);
+	dev->mode_config.num_crtc--;
+	WARN_ON(crtc->state && !crtc->funcs->atomic_destroy_state);
+	if (crtc->state && crtc->funcs->atomic_destroy_state)
+		crtc->funcs->atomic_destroy_state(crtc, crtc->state);
-	dev->mode_config.num_crtc--;
+	memset(crtc, 0, sizeof(*crtc));
+}
 EXPORT_SYMBOL(drm_crtc_cleanup);
 	drm_mode_object_put(dev, &connector->base);
 	kfree(connector->name);
 	connector->name = NULL;
 	list_del(&connector->head);
 	dev->mode_config.num_connector--;
+	WARN_ON(connector->state && !connector->funcs->atomic_destroy_state);
+	if (connector->state && connector->funcs->atomic_destroy_state)
+		connector->funcs->atomic_destroy_state(connector,
+						       connector->state);
+	memset(connector, 0, sizeof(*connector));
+}
 EXPORT_SYMBOL(drm_connector_cleanup);
+/**
+ * drm_connector_index - find the index of a registered connector
+ * @connector: connector to find index for
+ *
+ * Given a registered connector, return the index of that connector within a DRM
+ * device's list of connectors.
+ */
+unsigned int drm_connector_index(struct drm_connector *connector)
+{
+	unsigned int index = 0;
+	struct drm_connector *tmp;
+	struct drm_mode_config *config = &connector->dev->mode_config;
+	WARN_ON(!drm_modeset_is_locked(&config->connection_mutex));
+	list_for_each_entry(tmp, &connector->dev->mode_config.connector_list, head) {
+		if (tmp == connector)
+			return index;
+		index++;
+	}
+	BUG();
+}
+EXPORT_SYMBOL(drm_connector_index);
 /**
  * drm_connector_register - register a connector
  * @connector: the connector to register
+ *
  * Register userspace interfaces for a connector
 	drm_modeset_lock_all(dev);
 	drm_mode_object_put(dev, &bridge->base);
 	list_del(&bridge->head);
 	dev->mode_config.num_bridge--;
 	drm_modeset_unlock_all(dev);
+	memset(bridge, 0, sizeof(*bridge));
+}
 EXPORT_SYMBOL(drm_bridge_cleanup);
 /**
+{
 	struct drm_device *dev = encoder->dev;
 	drm_modeset_lock_all(dev);
 	drm_mode_object_put(dev, &encoder->base);
 	kfree(encoder->name);
-	encoder->name = NULL;
 	list_del(&encoder->head);
 	dev->mode_config.num_encoder--;
 	drm_modeset_unlock_all(dev);
+	memset(encoder, 0, sizeof(*encoder));
+}
 EXPORT_SYMBOL(drm_encoder_cleanup);
 /**
 		   const uint32_t *formats, uint32_t format_count,
 			     enum drm_plane_type type)
+{
 	int ret;
-	drm_modeset_lock_all(dev);
 	ret = drm_mode_object_get(dev, &plane->base, DRM_MODE_OBJECT_PLANE);
 	if (ret)
+		return ret;
-		goto out;
+	drm_modeset_lock_init(&plane->mutex);
 	plane->base.properties = &plane->properties;
 	plane->dev = dev;
 	plane->funcs = funcs;
 	plane->format_types = kmalloc(sizeof(uint32_t) * format_count,
 				      GFP_KERNEL);
 	if (!plane->format_types) {
 		DRM_DEBUG_KMS("out of memory when allocating plane\n");
-		drm_mode_object_put(dev, &plane->base);
-		ret = -ENOMEM;
+		drm_mode_object_put(dev, &plane->base);
-		goto out;
+		return -ENOMEM;
+	}
 	drm_object_attach_property(&plane->base,
 				   dev->mode_config.plane_type_property,
-				   plane->type);
- out:
-	drm_modeset_unlock_all(dev);
+				   plane->type);
-	return ret;
+	return 0;
+}
 EXPORT_SYMBOL(drm_universal_plane_init);
 		list_del(&plane->head);
 	dev->mode_config.num_total_plane--;
 	if (plane->type == DRM_PLANE_TYPE_OVERLAY)
 		dev->mode_config.num_overlay_plane--;
 	drm_modeset_unlock_all(dev);
+	WARN_ON(plane->state && !plane->funcs->atomic_destroy_state);
+	if (plane->state && plane->funcs->atomic_destroy_state)
+		plane->funcs->atomic_destroy_state(plane, plane->state);
+	memset(plane, 0, sizeof(*plane));
+}
 EXPORT_SYMBOL(drm_plane_cleanup);
+/**
+ * drm_plane_index - find the index of a registered plane
+ * @plane: plane to find index for
+ *
+ * Given a registered plane, return the index of that CRTC within a DRM
+ * device's list of planes.
+ */
+unsigned int drm_plane_index(struct drm_plane *plane)
+{
+	unsigned int index = 0;
+	struct drm_plane *tmp;
+	list_for_each_entry(tmp, &plane->dev->mode_config.plane_list, head) {
+		if (tmp == plane)
+			return index;
+		index++;
+	}
+	BUG();
+}
+EXPORT_SYMBOL(drm_plane_index);
 /**
  * drm_plane_force_disable - Forcibly disable a plane
  * @plane: plane to disable
+ *
  * Forces the plane to be disabled.
+ *
  * Used when the plane's current framebuffer is destroyed,
  * and when restoring fbdev mode.
  */
 void drm_plane_force_disable(struct drm_plane *plane)
-{
 	struct drm_framebuffer *old_fb = plane->fb;
 	int ret;
+	if (!plane->fb)
-	if (!old_fb)
+		return;
 		return;
 	plane->old_fb = plane->fb;
+	ret = plane->funcs->disable_plane(plane);
-	ret = plane->funcs->disable_plane(plane);
+	if (ret) {
-	if (ret) {
+		DRM_ERROR("failed to disable plane with busy fb\n");
-		DRM_ERROR("failed to disable plane with busy fb\n");
+		plane->old_fb = NULL;
 		return;
+	}
 	/* disconnect the plane from the fb and crtc: */
-	/* disconnect the plane from the fb and crtc: */
+	__drm_framebuffer_unreference(plane->old_fb);
-	__drm_framebuffer_unreference(old_fb);
+	plane->old_fb = NULL;
 	plane->fb = NULL;
 				       DRM_MODE_PROP_BLOB |
 				       DRM_MODE_PROP_IMMUTABLE,
 				       "PATH", 0);
 	dev->mode_config.path_property = dev_path;
+	dev->mode_config.tile_property = drm_property_create(dev,
+							     DRM_MODE_PROP_BLOB |
+							     DRM_MODE_PROP_IMMUTABLE,
+							     "TILE", 0);
 	return 0;
+}
  * Called by a driver's TV initialization routine, this function creates
  * the TV specific connector properties for a given device.  Caller is
  * responsible for allocating a list of format names and passing them to
  * this routine.
  */
-int drm_mode_create_tv_properties(struct drm_device *dev, int num_modes,
+int drm_mode_create_tv_properties(struct drm_device *dev,
+				  unsigned int num_modes,
 				  char *modes[])
+{
 	struct drm_property *tv_selector;
 	struct drm_property *tv_subconnector;
-	int i;
+	unsigned int i;
 	if (dev->mode_config.tv_select_subconnector_property)
 		return 0;
+ *
  * Called by a driver the first time it's needed, must be attached to desired
  * connectors.
+ *
  * Returns:
- * Zero on success, errno on failure.
+ * Zero on success, negative errno on failure.
  */
 int drm_mode_create_aspect_ratio_property(struct drm_device *dev)
+{
 	if (dev->mode_config.aspect_ratio_property)
 		return 0;
 	return 0;
+}
+EXPORT_SYMBOL(drm_mode_create_dirty_info_property);
+/**
+ * drm_mode_create_suggested_offset_properties - create suggests offset properties
+ * @dev: DRM device
+ *
+ * Create the the suggested x/y offset property for connectors.
+ */
+int drm_mode_create_suggested_offset_properties(struct drm_device *dev)
+{
+	if (dev->mode_config.suggested_x_property && dev->mode_config.suggested_y_property)
+		return 0;
+	dev->mode_config.suggested_x_property =
+		drm_property_create_range(dev, DRM_MODE_PROP_IMMUTABLE, "suggested X", 0, 0xffffffff);
+	dev->mode_config.suggested_y_property =
+		drm_property_create_range(dev, DRM_MODE_PROP_IMMUTABLE, "suggested Y", 0, 0xffffffff);
+	if (dev->mode_config.suggested_x_property == NULL ||
+	    dev->mode_config.suggested_y_property == NULL)
+		return -ENOMEM;
+	return 0;
+}
-EXPORT_SYMBOL(drm_mode_create_dirty_info_property);
+EXPORT_SYMBOL(drm_mode_create_suggested_offset_properties);
 static int drm_mode_group_init(struct drm_device *dev, struct drm_mode_group *group)
+{
+ *
  * Convert a drm_mode_modeinfo into a drm_display_mode structure to return to
  * the caller.
+ *
  * Returns:
- * Zero on success, errno on failure.
+ * Zero on success, negative errno on failure.
  */
 static int drm_crtc_convert_umode(struct drm_display_mode *out,
 				  const struct drm_mode_modeinfo *in)
+{
 	if (in->clock > INT_MAX || in->vrefresh > INT_MAX)
  * them to the user, including CRTC, connector and framebuffer configuration.
+ *
  * Called by the user via ioctl.
+ *
  * Returns:
- * Zero on success, errno on failure.
+ * 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;
+		}
+	}
 	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. */
-	drm_modeset_lock_all(dev);
+	mutex_lock(&dev->mode_config.mutex);
 	if (!drm_is_primary_client(file_priv)) {
 		mode_group = NULL;
 	DRM_DEBUG_KMS("CRTC[%d] CONNECTORS[%d] ENCODERS[%d]\n", card_res->count_crtcs,
 		  card_res->count_connectors, card_res->count_encoders);
 out:
-	drm_modeset_unlock_all(dev);
+	mutex_unlock(&dev->mode_config.mutex);
 	return ret;
+}
  * Construct a CRTC configuration structure to return to the user.
+ *
  * Called by the user via ioctl.
+ *
  * Returns:
- * Zero on success, errno on failure.
+ * Zero on success, negative errno on failure.
  */
 int drm_mode_getcrtc(struct drm_device *dev,
 		     void *data, struct drm_file *file_priv)
+{
 	struct drm_mode_crtc *crtc_resp = data;
 	struct drm_crtc *crtc;
-	int ret = 0;
 	if (!drm_core_check_feature(dev, DRIVER_MODESET))
-		return -EINVAL;
-	drm_modeset_lock_all(dev);
+		return -EINVAL;
 	crtc = drm_crtc_find(dev, crtc_resp->crtc_id);
-	if (!crtc) {
-		ret = -ENOENT;
+	if (!crtc)
-		goto out;
+		return -ENOENT;
 	drm_modeset_lock_crtc(crtc, crtc->primary);
 	crtc_resp->x = crtc->x;
 	crtc_resp->y = crtc->y;
 		crtc_resp->mode_valid = 1;
 	} else {
 		crtc_resp->mode_valid = 0;
+	}
-	}
-out:
+	drm_modeset_unlock_crtc(crtc);
 	drm_modeset_unlock_all(dev);
-	return ret;
+	return 0;
+}
 		return false;
 	return true;
+}
+static struct drm_encoder *drm_connector_get_encoder(struct drm_connector *connector)
+{
+	/* For atomic drivers only state objects are synchronously updated and
+	 * protected by modeset locks, so check those first. */
+	if (connector->state)
+		return connector->state->best_encoder;
+	return connector->encoder;
+}
 /**
  * drm_mode_getconnector - get connector configuration
  * @dev: drm device for the ioctl
  * Construct a connector configuration structure to return to the user.
+ *
  * Called by the user via ioctl.
+ *
  * Returns:
- * Zero on success, errno on failure.
+ * Zero on success, negative errno on failure.
  */
 int drm_mode_getconnector(struct drm_device *dev, void *data,
 			  struct drm_file *file_priv)
+{
 	struct drm_mode_get_connector *out_resp = data;
 	struct drm_connector *connector;
+	struct drm_encoder *encoder;
 	struct drm_display_mode *mode;
 	int mode_count = 0;
 	int props_count = 0;
 	int encoders_count = 0;
 	int ret = 0;
 	out_resp->mm_width = connector->display_info.width_mm;
 	out_resp->mm_height = connector->display_info.height_mm;
 	out_resp->subpixel = connector->display_info.subpixel_order;
 	out_resp->connection = connector->status;
 	drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
+	encoder = drm_connector_get_encoder(connector);
-	if (connector->encoder)
+	if (encoder)
-		out_resp->encoder_id = connector->encoder->base.id;
+		out_resp->encoder_id = encoder->base.id;
 	else
 		out_resp->encoder_id = 0;
 	drm_modeset_unlock(&dev->mode_config.connection_mutex);
 	mutex_unlock(&dev->mode_config.mutex);
 	return ret;
+}
+static struct drm_crtc *drm_encoder_get_crtc(struct drm_encoder *encoder)
+{
+	struct drm_connector *connector;
+	struct drm_device *dev = encoder->dev;
+	bool uses_atomic = false;
+	/* For atomic drivers only state objects are synchronously updated and
+	 * protected by modeset locks, so check those first. */
+	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
+		if (!connector->state)
+			continue;
+		uses_atomic = true;
+		if (connector->state->best_encoder != encoder)
+			continue;
+		return connector->state->crtc;
+	}
+	/* Don't return stale data (e.g. pending async disable). */
+	if (uses_atomic)
+		return NULL;
+	return encoder->crtc;
+}
 /**
  * drm_mode_getencoder - get encoder configuration
  * @dev: drm device for the ioctl
  * Construct a encoder configuration structure to return to the user.
+ *
  * Called by the user via ioctl.
+ *
  * Returns:
- * Zero on success, errno on failure.
+ * Zero on success, negative errno on failure.
  */
 int drm_mode_getencoder(struct drm_device *dev, void *data,
 			struct drm_file *file_priv)
+{
 	struct drm_mode_get_encoder *enc_resp = data;
 	struct drm_encoder *encoder;
-	int ret = 0;
+	struct drm_crtc *crtc;
 	if (!drm_core_check_feature(dev, DRIVER_MODESET))
-		return -EINVAL;
 		return -EINVAL;
-	drm_modeset_lock_all(dev);
 	encoder = drm_encoder_find(dev, enc_resp->encoder_id);
-	if (!encoder) {
-		ret = -ENOENT;
+	if (!encoder)
+		return -ENOENT;
+	drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
-		goto out;
+	crtc = drm_encoder_get_crtc(encoder);
 	if (crtc)
 		enc_resp->crtc_id = crtc->base.id;
-	if (encoder->crtc)
+	else if (encoder->crtc)
+		enc_resp->crtc_id = encoder->crtc->base.id;
+	else
-		enc_resp->crtc_id = encoder->crtc->base.id;
+		enc_resp->crtc_id = 0;
-	else
+	drm_modeset_unlock(&dev->mode_config.connection_mutex);
 		enc_resp->crtc_id = 0;
 	enc_resp->encoder_type = encoder->encoder_type;
-	enc_resp->encoder_id = encoder->base.id;
-	enc_resp->possible_crtcs = encoder->possible_crtcs;
-	enc_resp->possible_clones = encoder->possible_clones;
+	enc_resp->encoder_id = encoder->base.id;
 	enc_resp->possible_crtcs = encoder->possible_crtcs;
-out:
+	enc_resp->possible_clones = encoder->possible_clones;
 	drm_modeset_unlock_all(dev);
-	return ret;
+	return 0;
  * Construct a list of plane ids to return to the user.
+ *
  * Called by the user via ioctl.
+ *
  * Returns:
- * Zero on success, errno on failure.
+ * Zero on success, negative errno on failure.
  */
 int drm_mode_getplane_res(struct drm_device *dev, void *data,
 			    struct drm_file *file_priv)
+{
 	struct drm_mode_get_plane_res *plane_resp = data;
 	struct drm_mode_config *config;
 	struct drm_plane *plane;
 	uint32_t __user *plane_ptr;
-	int copied = 0, ret = 0;
+	int copied = 0;
 	unsigned num_planes;
 	if (!drm_core_check_feature(dev, DRIVER_MODESET))
-		return -EINVAL;
 		return -EINVAL;
 	drm_modeset_lock_all(dev);
 	config = &dev->mode_config;
 	 */
 	if (num_planes &&
 	    (plane_resp->count_planes >= num_planes)) {
 		plane_ptr = (uint32_t __user *)(unsigned long)plane_resp->plane_id_ptr;
 		/* Plane lists are invariant, no locking needed. */
 		list_for_each_entry(plane, &config->plane_list, head) {
 			/*
 			 * Unless userspace set the 'universal planes'
 			 * capability bit, only advertise overlays.
 			 */
 			if (plane->type != DRM_PLANE_TYPE_OVERLAY &&
 			    !file_priv->universal_planes)
 				continue;
-			if (put_user(plane->base.id, plane_ptr + copied)) {
-				ret = -EFAULT;
-				goto out;
+			if (put_user(plane->base.id, plane_ptr + copied))
 				return -EFAULT;
 			copied++;
+		}
-	}
-	plane_resp->count_planes = num_planes;
+	}
-out:
+	plane_resp->count_planes = num_planes;
 	drm_modeset_unlock_all(dev);
-	return ret;
+	return 0;
+}
  * Construct a plane configuration structure to return to the user.
+ *
  * Called by the user via ioctl.
+ *
  * Returns:
- * Zero on success, errno on failure.
+ * Zero on success, negative errno on failure.
  */
 int drm_mode_getplane(struct drm_device *dev, void *data,
 			struct drm_file *file_priv)
+{
 	struct drm_mode_get_plane *plane_resp = data;
 	struct drm_plane *plane;
 	uint32_t __user *format_ptr;
-	int ret = 0;
 	if (!drm_core_check_feature(dev, DRIVER_MODESET))
-		return -EINVAL;
 		return -EINVAL;
-	drm_modeset_lock_all(dev);
 	plane = drm_plane_find(dev, plane_resp->plane_id);
-	if (!plane) {
-		ret = -ENOENT;
+	if (!plane)
-		goto out;
+		return -ENOENT;
 	drm_modeset_lock(&plane->mutex, NULL);
 	if (plane->crtc)
 		plane_resp->crtc_id = plane->crtc->base.id;
 	else
 		plane_resp->crtc_id = 0;
+	if (plane->fb)
-	if (plane->fb)
+		plane_resp->fb_id = plane->fb->base.id;
-		plane_resp->fb_id = plane->fb->base.id;
+	else
-	else
+		plane_resp->fb_id = 0;
 	    (plane_resp->count_format_types >= plane->format_count)) {
 		format_ptr = (uint32_t __user *)(unsigned long)plane_resp->format_type_ptr;
 		if (copy_to_user(format_ptr,
 				 plane->format_types,
 				 sizeof(uint32_t) * plane->format_count)) {
-			ret = -EFAULT;
+			return -EFAULT;
-			goto out;
+		}
+	}
 	plane_resp->count_format_types = plane->format_count;
-out:
-	drm_modeset_unlock_all(dev);
-	return ret;
+	return 0;
+}
 /*
  * update fails, this reference will be dropped before return; if it succeeds,
  * the previous framebuffer (if any) will be unreferenced instead.
+ *
  * src_{x,y,w,h} are provided in 16.16 fixed point format
  */
-static int setplane_internal(struct drm_plane *plane,
+static int __setplane_internal(struct drm_plane *plane,
 			     struct drm_crtc *crtc,
 			     struct drm_framebuffer *fb,
 			     int32_t crtc_x, int32_t crtc_y,
 			     uint32_t crtc_w, uint32_t crtc_h,
 			     /* src_{x,y,w,h} values are 16.16 fixed point */
 			     uint32_t src_x, uint32_t src_y,
 			     uint32_t src_w, uint32_t src_h)
+{
-	struct drm_device *dev = plane->dev;
-	struct drm_framebuffer *old_fb = NULL;
 	int ret = 0;
 	unsigned int fb_width, fb_height;
-	int i;
+	unsigned int i;
 	/* No fb means shut it down */
-	if (!fb) {
-		drm_modeset_lock_all(dev);
+	if (!fb) {
-		old_fb = plane->fb;
+		plane->old_fb = plane->fb;
 		ret = plane->funcs->disable_plane(plane);
 		if (!ret) {
 		plane->crtc = NULL;
 		plane->fb = NULL;
 		} else {
-			old_fb = NULL;
+			plane->old_fb = NULL;
-		}
 		drm_modeset_unlock_all(dev);
 		goto out;
+	}
 			      src_y >> 16, ((src_y & 0xffff) * 15625) >> 10);
 		ret = -ENOSPC;
 		goto out;
+	}
-	drm_modeset_lock_all(dev);
-	old_fb = plane->fb;
+	plane->old_fb = plane->fb;
 	ret = plane->funcs->update_plane(plane, crtc, fb,
 					 crtc_x, crtc_y, crtc_w, crtc_h,
 					 src_x, src_y, src_w, src_h);
 	if (!ret) {
 		plane->crtc = crtc;
 		plane->fb = fb;
 		fb = NULL;
 	} else {
-		old_fb = NULL;
+		plane->old_fb = NULL;
-	}
 	drm_modeset_unlock_all(dev);
 out:
 	if (fb)
 		drm_framebuffer_unreference(fb);
+	if (plane->old_fb)
-	if (old_fb)
+		drm_framebuffer_unreference(plane->old_fb);
+	plane->old_fb = NULL;
+	return ret;
+}
+static int setplane_internal(struct drm_plane *plane,
+			     struct drm_crtc *crtc,
+			     struct drm_framebuffer *fb,
+			     int32_t crtc_x, int32_t crtc_y,
+			     uint32_t crtc_w, uint32_t crtc_h,
+			     /* src_{x,y,w,h} values are 16.16 fixed point */
+			     uint32_t src_x, uint32_t src_y,
+			     uint32_t src_w, uint32_t src_h)
+{
+	int ret;
+	drm_modeset_lock_all(plane->dev);
+	ret = __setplane_internal(plane, crtc, fb,
+				  crtc_x, crtc_y, crtc_w, crtc_h,
-		drm_framebuffer_unreference(old_fb);
+				  src_x, src_y, src_w, src_h);
 	drm_modeset_unlock_all(plane->dev);
 	return ret;
 	return ret;
  * Set plane configuration, including placement, fb, scaling, and other factors.
  * Or pass a NULL fb to disable (planes may be disabled without providing a
  * valid crtc).
+ *
  * Returns:
- * Zero on success, errno on failure.
+ * Zero on success, negative errno on failure.
  */
 int drm_mode_setplane(struct drm_device *dev, void *data,
 		      struct drm_file *file_priv)
+{
 	struct drm_mode_set_plane *plane_req = data;
-	struct drm_mode_object *obj;
 	struct drm_plane *plane;
 	struct drm_crtc *crtc = NULL;
 	struct drm_framebuffer *fb = NULL;
 	/*
 	 * First, find the plane, crtc, and fb objects.  If not available,
 	 * we don't bother to call the driver.
 	 */
-	obj = drm_mode_object_find(dev, plane_req->plane_id,
-				   DRM_MODE_OBJECT_PLANE);
+	plane = drm_plane_find(dev, plane_req->plane_id);
-	if (!obj) {
+	if (!plane) {
 		DRM_DEBUG_KMS("Unknown plane ID %d\n",
 			      plane_req->plane_id);
 		return -ENOENT;
-	}
 	plane = obj_to_plane(obj);
 	if (plane_req->fb_id) {
 		fb = drm_framebuffer_lookup(dev, plane_req->fb_id);
 		if (!fb) {
 			DRM_DEBUG_KMS("Unknown framebuffer ID %d\n",
 				      plane_req->fb_id);
 			return -ENOENT;
-		}
+		}
 		obj = drm_mode_object_find(dev, plane_req->crtc_id,
-					   DRM_MODE_OBJECT_CRTC);
+		crtc = drm_crtc_find(dev, plane_req->crtc_id);
-		if (!obj) {
+		if (!crtc) {
 			DRM_DEBUG_KMS("Unknown crtc ID %d\n",
-				      plane_req->crtc_id);
-			return -ENOENT;
+				      plane_req->crtc_id);
 			return -ENOENT;
 		crtc = obj_to_crtc(obj);
+	}
+ *
  * This is a little helper to wrap internal calls to the ->set_config driver
  * interface. The only thing it adds is correct refcounting dance.
+ *
  * Returns:
- * Zero on success, errno on failure.
+ * Zero on success, negative errno on failure.
  */
 int drm_mode_set_config_internal(struct drm_mode_set *set)
+{
 	struct drm_crtc *crtc = set->crtc;
 	struct drm_framebuffer *fb;
 	 * NOTE: ->set_config can also disable other crtcs (if we steal all
 	 * connectors from it), hence we need to refcount the fbs across all
 	 * crtcs. Atomic modeset will have saner semantics ...
 	 */
 	list_for_each_entry(tmp, &crtc->dev->mode_config.crtc_list, head)
-		tmp->old_fb = tmp->primary->fb;
+		tmp->primary->old_fb = tmp->primary->fb;
 	fb = set->fb;
  * Build a new CRTC configuration based on user request.
+ *
  * Called by the user via ioctl.
+ *
  * Returns:
- * Zero on success, errno on failure.
+ * Zero on success, negative errno on failure.
  */
 int drm_mode_setcrtc(struct drm_device *dev, void *data,
 		     struct drm_file *file_priv)
+{
 	struct drm_mode_config *config = &dev->mode_config;
 	/*
 	 * If this crtc has a universal cursor plane, call that plane's update
 	 * handler rather than using legacy cursor handlers.
+	 */
-	 */
+	drm_modeset_lock_crtc(crtc, crtc->cursor);
-	if (crtc->cursor)
+	if (crtc->cursor) {
+		ret = drm_mode_cursor_universal(crtc, req, file_priv);
+		goto out;
-		return drm_mode_cursor_universal(crtc, req, file_priv);
+	}
 	drm_modeset_lock(&crtc->mutex, NULL);
 	if (req->flags & DRM_MODE_CURSOR_BO) {
 		if (!crtc->funcs->cursor_set && !crtc->funcs->cursor_set2) {
 			ret = -ENXIO;
 			ret = -EFAULT;
 			goto out;
+		}
+	}
 out:
-	drm_modeset_unlock(&crtc->mutex);
+	drm_modeset_unlock_crtc(crtc);
 	return ret;
  * Set the cursor configuration based on user request.
+ *
  * Called by the user via ioctl.
+ *
  * Returns:
- * Zero on success, errno on failure.
+ * Zero on success, negative errno on failure.
  */
 int drm_mode_cursor_ioctl(struct drm_device *dev,
 			void *data, struct drm_file *file_priv)
+{
 	struct drm_mode_cursor *req = data;
  * the hotspot of the pointer.
+ *
  * Called by the user via ioctl.
+ *
  * Returns:
- * Zero on success, errno on failure.
+ * Zero on success, negative errno on failure.
  */
 int drm_mode_cursor2_ioctl(struct drm_device *dev,
 			   void *data, struct drm_file *file_priv)
+{
 	struct drm_mode_cursor2 *req = data;
  * @dev: drm device for the ioctl
  * @data: data pointer for the ioctl
  * @file_priv: drm file for the ioctl call
+ *
  * Add a new FB to the specified CRTC, given a user request. This is the
- * original addfb ioclt which only supported RGB formats.
+ * original addfb ioctl which only supported RGB formats.
+ *
  * Called by the user via ioctl.
+ *
  * Returns:
- * Zero on success, errno on failure.
+ * Zero on success, negative errno on failure.
  */
 int drm_mode_addfb(struct drm_device *dev,
 		   void *data, struct drm_file *file_priv)
+{
 	struct drm_mode_fb_cmd *or = data;
 	struct drm_mode_fb_cmd2 r = {};
-	struct drm_mode_config *config = &dev->mode_config;
-	struct drm_framebuffer *fb;
-	int ret = 0;
+	int ret;
-	/* Use new struct with format internally */
+	/* convert to new format and call new ioctl */
 	r.fb_id = or->fb_id;
 	r.width = or->width;
 	r.height = or->height;
 	r.pitches[0] = or->pitch;
 	r.pixel_format = drm_mode_legacy_fb_format(or->bpp, or->depth);
-	r.handles[0] = or->handle;
-	if (!drm_core_check_feature(dev, DRIVER_MODESET))
-		return -EINVAL;
-	if ((config->min_width > r.width) || (r.width > config->max_width))
-		return -EINVAL;
-	if ((config->min_height > r.height) || (r.height > config->max_height))
-		return -EINVAL;
+	r.handles[0] = or->handle;
-	fb = dev->mode_config.funcs->fb_create(dev, file_priv, &r);
-	if (IS_ERR(fb)) {
+	ret = drm_mode_addfb2(dev, &r, file_priv);
-		DRM_DEBUG_KMS("could not create framebuffer\n");
-		return PTR_ERR(fb);
-	}
+	if (ret)
-	mutex_lock(&file_priv->fbs_lock);
-	or->fb_id = fb->base.id;
-	list_add(&fb->filp_head, &file_priv->fbs);
+		return ret;
 	DRM_DEBUG_KMS("[FB:%d]\n", fb->base.id);
-	mutex_unlock(&file_priv->fbs_lock);
+	or->fb_id = r.fb_id;
-	return ret;
+	return 0;
 	hsub = drm_format_horz_chroma_subsampling(r->pixel_format);
 	vsub = drm_format_vert_chroma_subsampling(r->pixel_format);
 	num_planes = drm_format_num_planes(r->pixel_format);
 	if (r->width == 0 || r->width % hsub) {
-		DRM_DEBUG_KMS("bad framebuffer width %u\n", r->height);
+		DRM_DEBUG_KMS("bad framebuffer width %u\n", r->width);
 		return -EINVAL;
+	}
  * and uses fourcc codes as pixel format specifiers.
+ *
  * Called by the user via ioctl.
+ *
  * Returns:
- * Zero on success, errno on failure.
+ * Zero on success, negative errno on failure.
  */
 int drm_mode_addfb2(struct drm_device *dev,
 		    void *data, struct drm_file *file_priv)
+{
 	struct drm_framebuffer *fb;
  * Remove the FB specified by the user.
+ *
  * Called by the user via ioctl.
+ *
  * Returns:
- * Zero on success, errno on failure.
+ * Zero on success, negative errno on failure.
  */
 int drm_mode_rmfb(struct drm_device *dev,
 		   void *data, struct drm_file *file_priv)
+{
 	struct drm_framebuffer *fb = NULL;
  * Lookup the FB given its ID and return info about it.
+ *
  * Called by the user via ioctl.
+ *
  * Returns:
- * Zero on success, errno on failure.
+ * Zero on success, negative errno on failure.
  */
 int drm_mode_getfb(struct drm_device *dev,
 		   void *data, struct drm_file *file_priv)
+{
 	struct drm_mode_fb_cmd *r = data;
 	r->width = fb->width;
 	r->depth = fb->depth;
 	r->bpp = fb->bits_per_pixel;
 	r->pitch = fb->pitches[0];
 	if (fb->funcs->create_handle) {
-		if (file_priv->is_master || capable(CAP_SYS_ADMIN)) {
+		if (file_priv->is_master || capable(CAP_SYS_ADMIN) ||
+		    drm_is_control_client(file_priv)) {
 			ret = fb->funcs->create_handle(fb, file_priv,
 						       &r->handle);
 		} else {
 			/* GET_FB() is an unprivileged ioctl so we must not
 			 * return a buffer-handle to non-master processes! For
  * implement the corresponding ->dirty framebuffer callback.
+ *
  * Called by the user via ioctl.
+ *
  * Returns:
- * Zero on success, errno on failure.
+ * Zero on success, negative errno on failure.
  */
 int drm_mode_dirtyfb_ioctl(struct drm_device *dev,
 			   void *data, struct drm_file *file_priv)
+{
 	struct drm_clip_rect __user *clips_ptr;
  * Destroy all the FBs associated with @filp.
+ *
  * Called by the user via ioctl.
+ *
  * Returns:
- * Zero on success, errno on failure.
+ * Zero on success, negative errno on failure.
  */
 void drm_fb_release(struct drm_file *priv)
+{
 	struct drm_device *dev = priv->minor->dev;
 	struct drm_framebuffer *fb, *tfb;
+	/*
+	 * When the file gets released that means no one else can access the fb
+	 * list any more, so no need to grab fpriv->fbs_lock. And we need to
+	 * avoid upsetting lockdep since the universal cursor code adds a
+	 * framebuffer while holding mutex locks.
+	 *
+	 * Note that a real deadlock between fpriv->fbs_lock and the modeset
+	 * locks is impossible here since no one else but this function can get
+	 * at it any more.
-	mutex_lock(&priv->fbs_lock);
+	 */
 	list_for_each_entry_safe(fb, tfb, &priv->fbs, filp_head) {
 		mutex_lock(&dev->mode_config.fb_lock);
 		list_del_init(&fb->filp_head);
 		/* This will also drop the fpriv->fbs reference. */
 		drm_framebuffer_remove(fb);
-	}
 	mutex_unlock(&priv->fbs_lock);
+}
 #endif
+ *
  * This creates a new generic drm property which can then be attached to a drm
  * object with drm_object_attach_property. The returned property object must be
  * freed with drm_property_destroy.
+ *
+ * Note that the DRM core keeps a per-device list of properties and that, if
+ * drm_mode_config_cleanup() is called, it will destroy all properties created
+ * by the driver.
+ *
  * Returns:
  * A pointer to the newly created property on success, NULL on failure.
  */
 struct drm_property *drm_property_create(struct drm_device *dev, int flags,
 					 const char *name, int num_values)
 	if (ret)
 		goto fail;
 	property->flags = flags;
 	property->num_values = num_values;
-	INIT_LIST_HEAD(&property->enum_blob_list);
+	INIT_LIST_HEAD(&property->enum_list);
 	if (name) {
 		strncpy(property->name, name, DRM_PROP_NAME_LEN);
  * drm_property_create_bitmask - create a new bitmask property type
  * @dev: drm device
  * @flags: flags specifying the property type
  * @name: name of the property
  * @props: enumeration lists with property bitflags
- * @num_values: number of pre-defined values
+ * @num_props: size of the @props array
+ * @supported_bits: bitmask of all supported enumeration values
+ *
- * This creates a new generic drm property which can then be attached to a drm
+ * This creates a new bitmask drm property which can then be attached to a drm
  * object with drm_object_attach_property. The returned property object must be
  * freed with drm_property_destroy.
+ *
  * Compared to plain enumeration properties userspace is allowed to set any
  * or'ed together combination of the predefined property bitflag values
+ *
  * This creates a new generic drm property which can then be attached to a drm
  * object with drm_object_attach_property. The returned property object must be
  * freed with drm_property_destroy.
+ *
- * Userspace is allowed to set any interger value in the (min, max) range
+ * Userspace is allowed to set any integer value in the (min, max) range
  * inclusive.
+ *
  * Returns:
  * A pointer to the newly created property on success, NULL on failure.
  */
 	 */
 	if (drm_property_type_is(property, DRM_MODE_PROP_BITMASK) &&
 			(value > 63))
 		return -EINVAL;
-	if (!list_empty(&property->enum_blob_list)) {
+	if (!list_empty(&property->enum_list)) {
-		list_for_each_entry(prop_enum, &property->enum_blob_list, head) {
+		list_for_each_entry(prop_enum, &property->enum_list, head) {
 			if (prop_enum->value == value) {
 				strncpy(prop_enum->name, name, DRM_PROP_NAME_LEN);
 				prop_enum->name[DRM_PROP_NAME_LEN-1] = '\0';
 				return 0;
 	strncpy(prop_enum->name, name, DRM_PROP_NAME_LEN);
 	prop_enum->name[DRM_PROP_NAME_LEN-1] = '\0';
 	prop_enum->value = value;
 	property->values[index] = value;
-	list_add_tail(&prop_enum->head, &property->enum_blob_list);
+	list_add_tail(&prop_enum->head, &property->enum_list);
 	return 0;
+}
 EXPORT_SYMBOL(drm_property_add_enum);
  */
 void drm_property_destroy(struct drm_device *dev, struct drm_property *property)
+{
 	struct drm_property_enum *prop_enum, *pt;
-	list_for_each_entry_safe(prop_enum, pt, &property->enum_blob_list, head) {
+	list_for_each_entry_safe(prop_enum, pt, &property->enum_list, head) {
 		list_del(&prop_enum->head);
 		kfree(prop_enum);
+	}
+}
 EXPORT_SYMBOL(drm_object_property_get_value);
 #if 0
 /**
- * drm_mode_getproperty_ioctl - get the current value of a connector's property
+ * drm_mode_getproperty_ioctl - get the property metadata
  * @dev: DRM device
  * @data: ioctl data
  * @file_priv: DRM file info
  *
+ * This function retrieves the metadata for a given property, like the different
+ * possible values for an enum property or the limits for a range property.
+ *
- * This function retrieves the current value for an connectors's property.
+ * Blob properties are special
+ *
  * Called by the user via ioctl.
+ *
  * Returns:
- * Zero on success, errno on failure.
+ * Zero on success, negative errno on failure.
  */
 int drm_mode_getproperty_ioctl(struct drm_device *dev,
 			       void *data, struct drm_file *file_priv)
+{
 	struct drm_mode_get_property *out_resp = data;
 	struct drm_property *property;
-	int enum_count = 0;
-	int blob_count = 0;
+	int enum_count = 0;
 	int value_count = 0;
 	int ret = 0, i;
 	int copied;
 	struct drm_property_enum *prop_enum;
-	struct drm_mode_property_enum __user *enum_ptr;
-	struct drm_property_blob *prop_blob;
-	uint32_t __user *blob_id_ptr;
+	struct drm_mode_property_enum __user *enum_ptr;
-	uint64_t __user *values_ptr;
-	uint32_t __user *blob_length_ptr;
+	uint64_t __user *values_ptr;
 	if (!drm_core_check_feature(dev, DRIVER_MODESET))
 		goto done;
+	}
 	if (drm_property_type_is(property, DRM_MODE_PROP_ENUM) ||
 			drm_property_type_is(property, DRM_MODE_PROP_BITMASK)) {
-		list_for_each_entry(prop_enum, &property->enum_blob_list, head)
+		list_for_each_entry(prop_enum, &property->enum_list, head)
-			enum_count++;
-	} else if (drm_property_type_is(property, DRM_MODE_PROP_BLOB)) {
-		list_for_each_entry(prop_blob, &property->enum_blob_list, head)
-			blob_count++;
+			enum_count++;
+	}
 	if (drm_property_type_is(property, DRM_MODE_PROP_ENUM) ||
 			drm_property_type_is(property, DRM_MODE_PROP_BITMASK)) {
 		if ((out_resp->count_enum_blobs >= enum_count) && enum_count) {
 			copied = 0;
 			enum_ptr = (struct drm_mode_property_enum __user *)(unsigned long)out_resp->enum_blob_ptr;
-			list_for_each_entry(prop_enum, &property->enum_blob_list, head) {
+			list_for_each_entry(prop_enum, &property->enum_list, head) {
 				if (copy_to_user(&enum_ptr[copied].value, &prop_enum->value, sizeof(uint64_t))) {
 					ret = -EFAULT;
 					goto done;
+			}
+		}
 		out_resp->count_enum_blobs = enum_count;
+	}
-	if (drm_property_type_is(property, DRM_MODE_PROP_BLOB)) {
+	/*
-		if ((out_resp->count_enum_blobs >= blob_count) && blob_count) {
-			copied = 0;
+	 * NOTE: The idea seems to have been to use this to read all the blob
-			blob_id_ptr = (uint32_t __user *)(unsigned long)out_resp->enum_blob_ptr;
+	 * property values. But nothing ever added them to the corresponding
-			blob_length_ptr = (uint32_t __user *)(unsigned long)out_resp->values_ptr;
+	 * list, userspace always used the special-purpose get_blob ioctl to
-			list_for_each_entry(prop_blob, &property->enum_blob_list, head) {
+	 * read the value for a blob property. It also doesn't make a lot of
-				if (put_user(prop_blob->base.id, blob_id_ptr + copied)) {
-					ret = -EFAULT;
+	 * sense to return values here when everything else is just metadata for
-					goto done;
+	 * the property itself.
-				}
+	 */
-				if (put_user(prop_blob->length, blob_length_ptr + copied)) {
-					ret = -EFAULT;
-					goto done;
-				}
-				copied++;
-			}
-		}
+	if (drm_property_type_is(property, DRM_MODE_PROP_BLOB))
-		out_resp->count_enum_blobs = blob_count;
 		out_resp->count_enum_blobs = 0;
 done:
 	drm_modeset_unlock_all(dev);
 	return ret;
+}
+#endif
-#endif
+static struct drm_property_blob *
-static struct drm_property_blob *drm_property_create_blob(struct drm_device *dev, int length,
+drm_property_create_blob(struct drm_device *dev, size_t length,
-							  void *data)
+			 const void *data)
+{
 	struct drm_property_blob *blob;
  * an object's blob property is just a normal modeset object id.
+ *
  * Called by the user via ioctl.
+ *
  * Returns:
- * Zero on success, errno on failure.
+ * Zero on success, negative errno on failure.
  */
 int drm_mode_getblob_ioctl(struct drm_device *dev,
 			   void *data, struct drm_file *file_priv)
+{
 	struct drm_mode_get_blob *out_resp = data;
 	drm_modeset_unlock_all(dev);
 	return ret;
+}
 #endif
+/**
+ * drm_mode_connector_set_path_property - set tile property on connector
+ * @connector: connector to set property on.
+ * @path: path to use for property.
+ *
+ * This creates a property to expose to userspace to specify a
+ * connector path. This is mainly used for DisplayPort MST where
+ * connectors have a topology and we want to allow userspace to give
+ * them more meaningful names.
+ *
+ * Returns:
+ * Zero on success, negative errno on failure.
  */
 int drm_mode_connector_set_path_property(struct drm_connector *connector,
-					 char *path)
+					 const char *path)
+{
-	struct drm_device *dev = connector->dev;
-	int ret, size;
+	struct drm_device *dev = connector->dev;
+	size_t size = strlen(path) + 1;
-	size = strlen(path) + 1;
+	int ret;
 	connector->path_blob_ptr = drm_property_create_blob(connector->dev,
 							    size, path);
 	return ret;
+}
 EXPORT_SYMBOL(drm_mode_connector_set_path_property);
+/**
+ * drm_mode_connector_set_tile_property - set tile property on connector
+ * @connector: connector to set property on.
+ *
+ * This looks up the tile information for a connector, and creates a
+ * property for userspace to parse if it exists. The property is of
+ * the form of 8 integers using ':' as a separator.
+ *
+ * Returns:
+ * Zero on success, errno on failure.
+ */
+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);
+	if (!connector->has_tile) {
+		connector->tile_blob_ptr = NULL;
+		ret = drm_object_property_set_value(&connector->base,
+						    dev->mode_config.tile_property, 0);
+		return ret;
+	}
+	snprintf(tile, 256, "%d:%d:%d:%d:%d:%d:%d:%d",
+		 connector->tile_group->id, connector->tile_is_single_monitor,
+		 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);
+	return ret;
+}
+EXPORT_SYMBOL(drm_mode_connector_set_tile_property);
 /**
  * drm_mode_connector_update_edid_property - update the edid property of a connector
  * @connector: drm connector
  * @edid: new value of the edid property
+ *
+ *
  * Returns:
  * Zero on success, errno on failure.
  */
 int drm_mode_connector_update_edid_property(struct drm_connector *connector,
-					    struct edid *edid)
+					    const struct edid *edid)
+{
 	struct drm_device *dev = connector->dev;
+	size_t size;
-	int ret, size;
+	int ret;
 	/* ignore requests to set edid when overridden */
 	if (connector->override_edid)
 	return ret;
+}
 EXPORT_SYMBOL(drm_mode_connector_update_edid_property);
 #if 0
 static int drm_mode_connector_set_obj_prop(struct drm_mode_object *obj,
 		drm_object_property_set_value(obj, property, value);
 	return ret;
+}
+/**
+ * drm_mode_plane_set_obj_prop - set the value of a property
+ * @plane: drm plane object to set property value for
+ * @property: property to set
+ * @value: value the property should be set to
+ *
+ * This functions sets a given property on a given plane object. This function
+ * calls the driver's ->set_property callback and changes the software state of
+ * the property if the callback succeeds.
+ *
+ * Returns:
-}
+ * Zero on success, error code on failure.
  */
-static int drm_mode_plane_set_obj_prop(struct drm_mode_object *obj,
+int drm_mode_plane_set_obj_prop(struct drm_plane *plane,
 				      struct drm_property *property,
 				      uint64_t value)
 {
 	int ret = -EINVAL;
-	struct drm_plane *plane = obj_to_plane(obj);
+	struct drm_mode_object *obj = &plane->base;
 	if (plane->funcs->set_property)
 		ret = plane->funcs->set_property(plane, property, value);
 	if (!ret)
+		drm_object_property_set_value(obj, property, value);
-		drm_object_property_set_value(obj, property, value);
+	return ret;
+}
-	return ret;
+EXPORT_SYMBOL(drm_mode_plane_set_obj_prop);
 #if 0
 /**
- * drm_mode_getproperty_ioctl - get the current value of a object's property
+ * drm_mode_obj_get_properties_ioctl - get the current value of a object's property
  * plane objects.
+ *
  * Called by the user via ioctl.
+ *
  * Returns:
- * Zero on success, errno on failure.
+ * Zero on success, negative errno on failure.
  */
 int drm_mode_obj_get_properties_ioctl(struct drm_device *dev, void *data,
 				      struct drm_file *file_priv)
+{
 	struct drm_mode_obj_get_properties *arg = data;
  * crtc and plane objects.
+ *
  * Called by the user via ioctl.
+ *
  * Returns:
- * Zero on success, errno on failure.
+ * Zero on success, negative errno on failure.
  */
 int drm_mode_obj_set_property_ioctl(struct drm_device *dev, void *data,
 				    struct drm_file *file_priv)
+{
 	struct drm_mode_obj_set_property *arg = data;
 		break;
 	case DRM_MODE_OBJECT_CRTC:
 		ret = drm_mode_crtc_set_obj_prop(arg_obj, property, arg->value);
 		break;
 	case DRM_MODE_OBJECT_PLANE:
-		ret = drm_mode_plane_set_obj_prop(arg_obj, property, arg->value);
+		ret = drm_mode_plane_set_obj_prop(obj_to_plane(arg_obj),
+						  property, arg->value);
 				break;
+			}
 out:
  * This function links up a connector to an encoder. Note that the routing
  * restrictions between encoders and crtcs are exposed to userspace through the
  * possible_clones and possible_crtcs bitmasks.
+ *
  * Returns:
- * Zero on success, errno on failure.
+ * Zero on success, negative errno on failure.
  */
 int drm_mode_connector_attach_encoder(struct drm_connector *connector,
 				      struct drm_encoder *encoder)
+{
 	int i;
  * Drivers which support gamma tables should set this to the supported gamma
  * table size when initializing the CRTC. Currently the drm core only supports a
  * fixed gamma table size.
+ *
  * Returns:
- * Zero on success, errno on failure.
+ * Zero on success, negative errno on failure.
  */
 int drm_mode_crtc_set_gamma_size(struct drm_crtc *crtc,
 				  int gamma_size)
+{
 	crtc->gamma_size = gamma_size;
  * inquire the required gamma table size through drm_mode_gamma_get_ioctl.
+ *
  * Called by the user via ioctl.
+ *
  * Returns:
- * Zero on success, errno on failure.
+ * Zero on success, negative errno on failure.
  */
 int drm_mode_gamma_set_ioctl(struct drm_device *dev,
 			     void *data, struct drm_file *file_priv)
+{
 	struct drm_mode_crtc_lut *crtc_lut = data;
  * allocated storage.
+ *
  * Called by the user via ioctl.
+ *
  * Returns:
- * Zero on success, errno on failure.
+ * Zero on success, negative errno on failure.
  */
 int drm_mode_gamma_get_ioctl(struct drm_device *dev,
 			     void *data, struct drm_file *file_priv)
+{
 	struct drm_mode_crtc_lut *crtc_lut = data;
  * 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;
+	list_for_each_entry(plane, &dev->mode_config.plane_list, head)
+		if (plane->funcs->reset)
+			plane->funcs->reset(plane);
 	list_for_each_entry(crtc, &dev->mode_config.crtc_list, head)
 		if (crtc->funcs->reset)
 			crtc->funcs->reset(crtc);
+	}
+}
 EXPORT_SYMBOL(drm_format_vert_chroma_subsampling);
+/**
+ * drm_rotation_simplify() - Try to simplify the rotation
+ * @rotation: Rotation to be simplified
+ * @supported_rotations: Supported rotations
+ *
+ * Attempt to simplify the rotation to a form that is supported.
+ * Eg. if the hardware supports everything except DRM_REFLECT_X
+ * one could call this function like this:
+ *
+ * drm_rotation_simplify(rotation, BIT(DRM_ROTATE_0) |
+ *                       BIT(DRM_ROTATE_90) | BIT(DRM_ROTATE_180) |
+ *                       BIT(DRM_ROTATE_270) | BIT(DRM_REFLECT_Y));
+ *
+ * to eliminate the DRM_ROTATE_X flag. Depending on what kind of
+ * transforms the hardware supports, this function may not
+ * be able to produce a supported transform, so the caller should
+ * check the result afterwards.
+ */
+unsigned int drm_rotation_simplify(unsigned int rotation,
+				   unsigned int supported_rotations)
+{
+	if (rotation & ~supported_rotations) {
+		rotation ^= BIT(DRM_REFLECT_X) | BIT(DRM_REFLECT_Y);
+		rotation = (rotation & ~0xf) | BIT((ffs(rotation & 0xf) + 1) % 4);
+	}
+	return rotation;
+}
+EXPORT_SYMBOL(drm_rotation_simplify);
 /**
  * drm_mode_config_init - initialize DRM mode_configuration structure
  * @dev: DRM device
+ *
  * Initialize @dev's mode_config structure, used for tracking the graphics
 	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);
 	drm_modeset_lock_all(dev);
 	drm_mode_create_standard_connector_properties(dev);
 	drm_mode_create_standard_plane_properties(dev);
  * 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_bridge *bridge, *brt;
+	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(bridge, brt,
+				 &dev->mode_config.bridge_list, head) {
+		bridge->funcs->destroy(bridge);
+	}
+	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(blob, bt, &dev->mode_config.property_blob_list,
+				 head) {
+		drm_property_destroy_blob(dev, 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_remove(fb);
+	}
+	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);
+	}
+	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);
+struct drm_property *drm_mode_create_rotation_property(struct drm_device *dev,
+						       unsigned int supported_rotations)
+{
+	static const struct drm_prop_enum_list props[] = {
+		{ DRM_ROTATE_0,   "rotate-0" },
+		{ DRM_ROTATE_90,  "rotate-90" },
+		{ DRM_ROTATE_180, "rotate-180" },
+		{ DRM_ROTATE_270, "rotate-270" },
+		{ DRM_REFLECT_X,  "reflect-x" },
+		{ DRM_REFLECT_Y,  "reflect-y" },
+	};
+	return drm_property_create_bitmask(dev, 0, "rotation",
+					   props, ARRAY_SIZE(props),
+					   supported_rotations);
+}
+EXPORT_SYMBOL(drm_mode_create_rotation_property);
+/**
+ * DOC: Tile group
+ *
+ * Tile groups are used to represent tiled monitors with a unique
+ * integer identifier. Tiled monitors using DisplayID v1.3 have
+ * a unique 8-byte handle, we store this in a tile group, so we
+ * have a common identifier for all tiles in a monitor group.
+ */
+static void drm_tile_group_free(struct kref *kref)
+{
+	struct drm_tile_group *tg = container_of(kref, struct drm_tile_group, refcount);
+	struct drm_device *dev = tg->dev;
+	mutex_lock(&dev->mode_config.idr_mutex);
+	idr_remove(&dev->mode_config.tile_idr, tg->id);
+	mutex_unlock(&dev->mode_config.idr_mutex);
+	kfree(tg);
+}
+/**
+ * drm_mode_put_tile_group - drop a reference to a tile group.
+ * @dev: DRM device
+ * @tg: tile group to drop reference to.
+ *
+ * drop reference to tile group and free if 0.
+ */
+void drm_mode_put_tile_group(struct drm_device *dev,
+			     struct drm_tile_group *tg)
+{
+	kref_put(&tg->refcount, drm_tile_group_free);
+}
+/**
+ * drm_mode_get_tile_group - get a reference to an existing tile group
+ * @dev: DRM device
+ * @topology: 8-bytes unique per monitor.
+ *
+ * Use the unique bytes to get a reference to an existing tile group.
+ *
+ * RETURNS:
+ * tile group or NULL if not found.
+ */
+struct drm_tile_group *drm_mode_get_tile_group(struct drm_device *dev,
+					       char topology[8])
+{
+	struct drm_tile_group *tg;
+	int id;
+	mutex_lock(&dev->mode_config.idr_mutex);
+	idr_for_each_entry(&dev->mode_config.tile_idr, tg, id) {
+		if (!memcmp(tg->group_data, topology, 8)) {
+//			if (!kref_get_unless_zero(&tg->refcount))
+//				tg = NULL;
+			mutex_unlock(&dev->mode_config.idr_mutex);
+			return tg;
+		}
+	}
+	mutex_unlock(&dev->mode_config.idr_mutex);
+	return NULL;
+}
+/**
+ * drm_mode_create_tile_group - create a tile group from a displayid description
+ * @dev: DRM device
+ * @topology: 8-bytes unique per monitor.
+ *
+ * Create a tile group for the unique monitor, and get a unique
+ * identifier for the tile group.
+ *
+ * RETURNS:
+ * new tile group or error.
+ */
+struct drm_tile_group *drm_mode_create_tile_group(struct drm_device *dev,
+						  char topology[8])
+{
+	struct drm_tile_group *tg;
+	int ret;
+	tg = kzalloc(sizeof(*tg), GFP_KERNEL);
+	if (!tg)
+		return ERR_PTR(-ENOMEM);
+	kref_init(&tg->refcount);
+	memcpy(tg->group_data, topology, 8);
+	tg->dev = dev;
+	mutex_lock(&dev->mode_config.idr_mutex);
+	ret = idr_alloc(&dev->mode_config.tile_idr, tg, 1, 0, GFP_KERNEL);
+	if (ret >= 0) {
+		tg->id = ret;
+	} else {
+		kfree(tg);
+		tg = ERR_PTR(ret);
+	}
+	mutex_unlock(&dev->mode_config.idr_mutex);
+	return tg;
+}

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/drm_crtc.c @ 5367 – Rev 5060 → 5271