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

 #include
 #include
 #include
 #include
 #include
+#include
+#include "drm_crtc_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
- * scheme isn't (yet) implemented.
+ * 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;
-	struct drm_crtc *crtc;
+	int ret;
+	ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
+	if (WARN_ON(!ctx))
+		return;
+	mutex_lock(&config->mutex);
+	drm_modeset_acquire_init(ctx, 0);
+retry:
-	mutex_lock(&dev->mode_config.mutex);
+	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);
-	list_for_each_entry(crtc, &dev->mode_config.crtc_list, head)
+		goto retry;
 		mutex_lock_nest_lock(&crtc->mutex, &dev->mode_config.mutex);
+}
 EXPORT_SYMBOL(drm_modeset_lock_all);
+/**
  * drm_modeset_unlock_all - drop all modeset locks
-/**
+ * @dev: device
  * 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;
- */
-void drm_modeset_unlock_all(struct drm_device *dev)
+	if (WARN_ON(!ctx))
+		return;
 	config->acquire_ctx = NULL;
-	struct drm_crtc *crtc;
+	drm_modeset_drop_locks(ctx);
 	drm_modeset_acquire_fini(ctx);
 	list_for_each_entry(crtc, &dev->mode_config.crtc_list, head)
-		mutex_unlock(&crtc->mutex);
+	kfree(ctx);
+	mutex_unlock(&dev->mode_config.mutex);
+}
-	mutex_unlock(&dev->mode_config.mutex);
+EXPORT_SYMBOL(drm_modeset_unlock_all);
-EXPORT_SYMBOL(drm_modeset_unlock_all);
+/**
  * drm_warn_on_modeset_not_all_locked - check that all modeset locks are locked
-/**
+ * @dev: device
- * drm_warn_on_modeset_not_all_locked - check that all modeset locks are locked
+ *
+ * Useful as a debug assert.
- * @dev: device
+ */
- */
+void drm_warn_on_modeset_not_all_locked(struct drm_device *dev)
 void drm_warn_on_modeset_not_all_locked(struct drm_device *dev)
 	struct drm_crtc *crtc;
 	{ DRM_MODE_DPMS_OFF, "Off" }
 };
+DRM_ENUM_NAME_FN(drm_get_dpms_name, drm_dpms_enum_list)
+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" },
-DRM_ENUM_NAME_FN(drm_get_dpms_name, drm_dpms_enum_list)
+};
 /*
  * Optional properties
  */
 	{ DRM_MODE_SCALE_FULLSCREEN, "Full" },
 	{ DRM_MODE_SCALE_CENTER, "Center" },
 	{ DRM_MODE_SCALE_ASPECT, "Full aspect" },
 };
+static const struct drm_prop_enum_list drm_aspect_ratio_enum_list[] = {
+	{ DRM_MODE_PICTURE_ASPECT_NONE, "Automatic" },
+	{ DRM_MODE_PICTURE_ASPECT_4_3, "4:3" },
+	{ DRM_MODE_PICTURE_ASPECT_16_9, "16:9" },
+};
 /*
  * Non-global properties, but "required" for certain connectors.
  */
 static const struct drm_prop_enum_list drm_dvi_i_select_enum_list[] =
 	{ DRM_MODE_ENCODER_TMDS, "TMDS" },
 	{ DRM_MODE_ENCODER_LVDS, "LVDS" },
 	{ DRM_MODE_ENCODER_TVDAC, "TV" },
 	{ DRM_MODE_ENCODER_VIRTUAL, "Virtual" },
 	{ DRM_MODE_ENCODER_DSI, "DSI" },
+	{ DRM_MODE_ENCODER_DPMST, "DP MST" },
+};
+static const struct drm_prop_enum_list drm_subpixel_enum_list[] =
+{
+	{ SubPixelUnknown, "Unknown" },
+	{ SubPixelHorizontalRGB, "Horizontal RGB" },
+	{ SubPixelHorizontalBGR, "Horizontal BGR" },
+	{ SubPixelVerticalRGB, "Vertical RGB" },
+	{ SubPixelVerticalBGR, "Vertical BGR" },
+	{ SubPixelNone, "None" },
 };
 void drm_connector_ida_init(void)
+{
 	for (i = 0; i < ARRAY_SIZE(drm_connector_enum_list); i++)
 		ida_destroy(&drm_connector_enum_list[i].ida);
-}
+}
-const char *drm_get_encoder_name(const struct drm_encoder *encoder)
-{
-	static char buf[32];
-	snprintf(buf, 32, "%s-%d",
-		 drm_encoder_enum_list[encoder->encoder_type].name,
-		 encoder->base.id);
-	return buf;
-}
-EXPORT_SYMBOL(drm_get_encoder_name);
+/**
+ * drm_get_connector_status_name - return a string for connector status
-const char *drm_get_connector_name(const struct drm_connector *connector)
-{
-	static char buf[32];
+ * @status: connector status to compute name of
-	snprintf(buf, 32, "%s-%d",
+ *
-		 drm_connector_enum_list[connector->connector_type].name,
-		 connector->connector_type_id);
+ * In contrast to the other drm_get_*_name functions this one here returns a
-	return buf;
-}
-EXPORT_SYMBOL(drm_get_connector_name);
+ * const pointer and hence is threadsafe.
  */
 const char *drm_get_connector_status_name(enum drm_connector_status status)
+{
 	if (status == connector_status_connected)
 	else
 		return "unknown";
+}
 EXPORT_SYMBOL(drm_get_connector_status_name);
+/**
+ * drm_get_subpixel_order_name - return a string for a given subpixel enum
+ * @order: enum of subpixel_order
+ *
+ * Note you could abuse this and return something out of bounds, but that
+ * would be a caller error.  No unscrubbed user data should make it here.
+ */
+const char *drm_get_subpixel_order_name(enum subpixel_order order)
+{
+	return drm_subpixel_enum_list[order].name;
+}
+EXPORT_SYMBOL(drm_get_subpixel_order_name);
 static char printable_char(int c)
+{
 	return isascii(c) && isprint(c) ? c : '?';
+}
+/**
+ * drm_get_format_name - return a string for drm fourcc format
+ * @format: format to compute name of
+ *
+ * Note that the buffer used by this function is globally shared and owned by
+ * the function itself.
+ *
  * FIXME: This isn't really multithreading safe.
  */
 const char *drm_get_format_name(uint32_t format)
+{
 	return buf;
+}
 EXPORT_SYMBOL(drm_get_format_name);
-/**
- * drm_mode_object_get - allocate a new modeset identifier
- * @dev: DRM device
+/*
- * @obj: object pointer, used to generate unique ID
- * @obj_type: object type
- *
- * Create a unique identifier based on @ptr in @dev's identifier space.  Used
- * for tracking modes, CRTCs and connectors.
- *
- * RETURNS:
- * New unique (relative to other objects in @dev) integer identifier for the
+ * Internal function to assign a slot in the object idr and optionally
- * object.
+ * register the object into the idr.
  */
+static int drm_mode_object_get_reg(struct drm_device *dev,
+				   struct drm_mode_object *obj,
-static int drm_mode_object_get(struct drm_device *dev,
+				   uint32_t obj_type,
-			       struct drm_mode_object *obj, uint32_t obj_type)
+				   bool register_obj)
+{
 	int ret;
 	mutex_lock(&dev->mode_config.idr_mutex);
-	ret = idr_alloc(&dev->mode_config.crtc_idr, obj, 1, 0, GFP_KERNEL);
+	ret = idr_alloc(&dev->mode_config.crtc_idr, register_obj ? obj : NULL, 1, 0, GFP_KERNEL);
 	if (ret >= 0) {
 		/*
 	return ret < 0 ? ret : 0;
+}
+/**
+ * drm_mode_object_get - allocate a new modeset identifier
+ * @dev: DRM device
+ * @obj: object pointer, used to generate unique ID
+ * @obj_type: object type
+ *
+ * Create a unique identifier based on @ptr in @dev's identifier space.  Used
+ * for tracking modes, CRTCs and connectors. Note that despite the _get postfix
+ * modeset identifiers are _not_ reference counted. Hence don't use this for
+ * reference counted modeset objects like framebuffers.
+ *
+ * Returns:
+ * New unique (relative to other objects in @dev) integer identifier for the
+ * object.
+ */
+int drm_mode_object_get(struct drm_device *dev,
+			       struct drm_mode_object *obj, uint32_t obj_type)
+{
+	return drm_mode_object_get_reg(dev, obj, obj_type, true);
+}
+static void drm_mode_object_register(struct drm_device *dev,
+				     struct drm_mode_object *obj)
+{
+	mutex_lock(&dev->mode_config.idr_mutex);
+	idr_replace(&dev->mode_config.crtc_idr, obj, obj->id);
+	mutex_unlock(&dev->mode_config.idr_mutex);
+}
 /**
  * drm_mode_object_put - free a modeset identifer
  * @dev: DRM device
  * @object: object to free
+ *
+ * Free @id from @dev's unique identifier pool. Note that despite the _get
  * postfix modeset identifiers are _not_ reference counted. Hence don't use this
- * Free @id from @dev's unique identifier pool.
+ * for reference counted modeset objects like framebuffers.
  */
-static void drm_mode_object_put(struct drm_device *dev,
+void drm_mode_object_put(struct drm_device *dev,
 				struct drm_mode_object *object)
+{
 	mutex_lock(&dev->mode_config.idr_mutex);
 	idr_remove(&dev->mode_config.crtc_idr, object->id);
+	mutex_unlock(&dev->mode_config.idr_mutex);
+}
+static struct drm_mode_object *_object_find(struct drm_device *dev,
+		uint32_t id, uint32_t type)
+{
+	struct drm_mode_object *obj = NULL;
+	mutex_lock(&dev->mode_config.idr_mutex);
+	obj = idr_find(&dev->mode_config.crtc_idr, id);
+	if (obj && type != DRM_MODE_OBJECT_ANY && obj->type != type)
+		obj = NULL;
+	if (obj && obj->id != id)
+		obj = NULL;
+	/* don't leak out unref'd fb's */
+	if (obj && (obj->type == DRM_MODE_OBJECT_FB))
+		obj = NULL;
+	mutex_unlock(&dev->mode_config.idr_mutex);
-	mutex_unlock(&dev->mode_config.idr_mutex);
+	return obj;
+}
 /**
  * drm_mode_object_find - look up a drm object with static lifetime
  * @dev: drm device
  * @id: id of the mode object
  * @type: type of the mode object
+ *
+ * Note that framebuffers cannot be looked up with this functions - since those
  * are reference counted, they need special treatment.  Even with
- * Note that framebuffers cannot be looked up with this functions - since those
+ * DRM_MODE_OBJECT_ANY (although that will simply return NULL
- * are reference counted, they need special treatment.
+ * rather than WARN_ON()).
  */
 struct drm_mode_object *drm_mode_object_find(struct drm_device *dev,
 		uint32_t id, uint32_t type)
+{
 	struct drm_mode_object *obj = NULL;
-	/* Framebuffers are reference counted and need their own lookup
-	 * function.*/
-	WARN_ON(type == DRM_MODE_OBJECT_FB);
-	mutex_lock(&dev->mode_config.idr_mutex);
-	obj = idr_find(&dev->mode_config.crtc_idr, id);
-	if (!obj || (obj->type != type) || (obj->id != id))
+	/* Framebuffers are reference counted and need their own lookup
-		obj = NULL;
+	 * function.*/
-	mutex_unlock(&dev->mode_config.idr_mutex);
+	WARN_ON(type == DRM_MODE_OBJECT_FB);
 	obj = _object_find(dev, id, type);
  * This functions publishes the fb and makes it available for concurrent access
  * by other users. Which means by this point the fb _must_ be fully set up -
  * since all the fb attributes are invariant over its lifetime, no further
  * locking but only correct reference counting is required.
+ *
- * RETURNS:
+ * Returns:
  * Zero on success, error code on failure.
  */
 int drm_framebuffer_init(struct drm_device *dev, struct drm_framebuffer *fb,
 			 const struct drm_framebuffer_funcs *funcs)
+{
  * @dev: drm device
  * @id: id of the fb object
+ *
  * If successful, this grabs an additional reference to the framebuffer -
  * callers need to make sure to eventually unreference the returned framebuffer
- * again.
+ * again, using @drm_framebuffer_unreference.
  */
 struct drm_framebuffer *drm_framebuffer_lookup(struct drm_device *dev,
 					       uint32_t id)
+{
 	struct drm_framebuffer *fb;
+ *
  * This functions decrements the fb's refcount and frees it if it drops to zero.
  */
 void drm_framebuffer_unreference(struct drm_framebuffer *fb)
+{
-	DRM_DEBUG("FB ID: %d\n", fb->base.id);
+	DRM_DEBUG("%p: FB ID: %d (%d)\n", fb, fb->base.id, atomic_read(&fb->refcount.refcount));
 	kref_put(&fb->refcount, drm_framebuffer_free);
+}
 EXPORT_SYMBOL(drm_framebuffer_unreference);
 /**
  * drm_framebuffer_reference - incr the fb refcnt
+ * @fb: framebuffer
+ *
- * @fb: framebuffer
+ * This functions increments the fb's refcount.
  */
 void drm_framebuffer_reference(struct drm_framebuffer *fb)
 {
-	DRM_DEBUG("FB ID: %d\n", fb->base.id);
+	DRM_DEBUG("%p: FB ID: %d (%d)\n", fb, fb->base.id, atomic_read(&fb->refcount.refcount));
 	kref_get(&fb->refcount);
+}
 EXPORT_SYMBOL(drm_framebuffer_reference);
 	BUG();
+}
 static void __drm_framebuffer_unreference(struct drm_framebuffer *fb)
 {
-	DRM_DEBUG("FB ID: %d\n", fb->base.id);
+	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);
+}
 /**
  * drm_framebuffer_cleanup - remove a framebuffer object
  * @fb: framebuffer to remove
  *
+ * Cleanup framebuffer. This function is intended to be used from the drivers
- * Cleanup references to a user-created framebuffer. This function is intended
+ * ->destroy callback. It can also be used to clean up driver private
- * to be used from the drivers ->destroy callback.
+ *  framebuffers embedded into a larger structure.
+ *
  * Note that this function does not remove the fb from active usuage - if it is
  * still used anywhere, hilarity can ensue since userspace could call getfb on
  * the id and get back -EINVAL. Obviously no concern at driver unload time.
 	 */
 	if (atomic_read(&fb->refcount.refcount) > 1) {
 		drm_modeset_lock_all(dev);
 		/* remove from any CRTC */
 		list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
-			if (crtc->fb == fb) {
+			if (crtc->primary->fb == fb) {
 				/* should turn off the crtc */
 				memset(&set, 0, sizeof(struct drm_mode_set));
 				set.crtc = crtc;
 				set.fb = NULL;
 				ret = drm_mode_set_config_internal(&set);
 	drm_framebuffer_unreference(fb);
+}
+EXPORT_SYMBOL(drm_framebuffer_remove);
-EXPORT_SYMBOL(drm_framebuffer_remove);
+DEFINE_WW_CLASS(crtc_ww_class);
+/**
-/**
+ * drm_crtc_init_with_planes - Initialise a new CRTC object with
- * drm_crtc_init - Initialise a new CRTC object
+ *    specified primary and cursor planes.
+ * @dev: DRM device
+ * @crtc: CRTC object to init
- * @dev: DRM device
+ * @primary: Primary plane for CRTC
- * @crtc: CRTC object to init
+ * @cursor: Cursor plane for CRTC
  * @funcs: callbacks for the new CRTC
+ *
  * Inits a new object created as base part of a driver crtc object.
+ *
- * RETURNS:
+ * Returns:
  * Zero on success, error code on failure.
+ */
+int drm_crtc_init_with_planes(struct drm_device *dev, struct drm_crtc *crtc,
- */
+			      struct drm_plane *primary,
-int drm_crtc_init(struct drm_device *dev, struct drm_crtc *crtc,
+			      struct drm_plane *cursor,
+		   const struct drm_crtc_funcs *funcs)
 		   const struct drm_crtc_funcs *funcs)
 	struct drm_mode_config *config = &dev->mode_config;
 	int ret;
 	crtc->dev = dev;
 	crtc->funcs = funcs;
+	crtc->invert_dimensions = false;
-	crtc->invert_dimensions = false;
 	drm_modeset_lock_all(dev);
-	drm_modeset_lock_all(dev);
+	drm_modeset_lock_init(&crtc->mutex);
-	mutex_init(&crtc->mutex);
+	/* dropped by _unlock_all(): */
-	mutex_lock_nest_lock(&crtc->mutex, &dev->mode_config.mutex);
+	drm_modeset_lock(&crtc->mutex, config->acquire_ctx);
 	ret = drm_mode_object_get(dev, &crtc->base, DRM_MODE_OBJECT_CRTC);
+	if (ret)
+		goto out;
+	crtc->base.properties = &crtc->properties;
+	list_add_tail(&crtc->head, &config->crtc_list);
+	config->num_crtc++;
 	if (ret)
-		goto out;
+	crtc->primary = primary;
 	crtc->cursor = cursor;
-	crtc->base.properties = &crtc->properties;
+	if (primary)
+		primary->possible_crtcs = 1 << drm_crtc_index(crtc);
-	list_add_tail(&crtc->head, &dev->mode_config.crtc_list);
+	if (cursor)
-	dev->mode_config.num_crtc++;
+		cursor->possible_crtcs = 1 << drm_crtc_index(crtc);
  out:
 	struct drm_device *dev = crtc->dev;
 		kfree(crtc->gamma_store);
+		crtc->gamma_store = NULL;
-		crtc->gamma_store = NULL;
+	drm_modeset_lock_fini(&crtc->mutex);
 	drm_mode_object_put(dev, &crtc->base);
 	list_del(&crtc->head);
 	dev->mode_config.num_crtc--;
 	BUG();
+}
-EXPORT_SYMBOL(drm_crtc_index);
-/**
- * drm_mode_probed_add - add a mode to a connector's probed mode list
- * @connector: connector the new mode
- * @mode: mode data
- *
- * Add @mode to @connector's mode list for later use.
- */
-void drm_mode_probed_add(struct drm_connector *connector,
-			 struct drm_display_mode *mode)
-{
-	list_add_tail(&mode->head, &connector->probed_modes);
-}
-EXPORT_SYMBOL(drm_mode_probed_add);
+EXPORT_SYMBOL(drm_crtc_index);
 /*
  * drm_mode_remove - remove and free a mode
  * @connector: connector list to modify
  * @connector_type: user visible type of the connector
+ *
  * Initialises a preallocated connector. Connectors should be
  * subclassed as part of driver connector objects.
+ *
- * RETURNS:
+ * Returns:
  * Zero on success, error code on failure.
  */
 int drm_connector_init(struct drm_device *dev,
 		     struct drm_connector *connector,
 		     const struct drm_connector_funcs *funcs,
 	struct ida *connector_ida =
 		&drm_connector_enum_list[connector_type].ida;
 	drm_modeset_lock_all(dev);
-	ret = drm_mode_object_get(dev, &connector->base, DRM_MODE_OBJECT_CONNECTOR);
+	ret = drm_mode_object_get_reg(dev, &connector->base, DRM_MODE_OBJECT_CONNECTOR, false);
 	if (ret)
-		goto out;
+		goto out_unlock;
 	connector->base.properties = &connector->properties;
 	connector->dev = dev;
 	connector->funcs = funcs;
 	connector->connector_type = connector_type;
 	connector->connector_type_id =
+		ida_simple_get(connector_ida, 1, 0, GFP_KERNEL);
+	if (connector->connector_type_id < 0) {
+		ret = connector->connector_type_id;
+		goto out_put;
-		ida_simple_get(connector_ida, 1, 0, GFP_KERNEL);
+	}
+	connector->name =
+		kasprintf(GFP_KERNEL, "%s-%d",
+			  drm_connector_enum_list[connector_type].name,
-	if (connector->connector_type_id < 0) {
+			  connector->connector_type_id);
-		ret = connector->connector_type_id;
+	if (!connector->name) {
+		ret = -ENOMEM;
-		drm_mode_object_put(dev, &connector->base);
+		goto out_put;
 		goto out;
 	INIT_LIST_HEAD(&connector->probed_modes);
 );
 	drm_object_attach_property(&connector->base,
+				      dev->mode_config.dpms_property, 0);
-				      dev->mode_config.dpms_property, 0);
+	connector->debugfs_entry = NULL;
+out_put:
+	if (ret)
+		drm_mode_object_put(dev, &connector->base);
- out:
+out_unlock:
 	drm_modeset_unlock_all(dev);
 	ida_remove(&drm_connector_enum_list[connector->connector_type].ida,
 		   connector->connector_type_id);
+	drm_mode_object_put(dev, &connector->base);
 	kfree(connector->name);
-	drm_mode_object_put(dev, &connector->base);
+	connector->name = NULL;
 	list_del(&connector->head);
 	dev->mode_config.num_connector--;
+}
+EXPORT_SYMBOL(drm_connector_cleanup);
+/**
+ * drm_connector_register - register a connector
+ * @connector: the connector to register
+ *
+ * Register userspace interfaces for a connector
+ *
+ * Returns:
+ * Zero on success, error code on failure.
+ */
+int drm_connector_register(struct drm_connector *connector)
+{
+	int ret;
+	drm_mode_object_register(connector->dev, &connector->base);
+	return 0;
+}
+EXPORT_SYMBOL(drm_connector_register);
+/**
+ * drm_connector_unregister - unregister a connector
+ * @connector: the connector to unregister
+ *
+ * Unregister userspace interfaces for a connector
+ */
+void drm_connector_unregister(struct drm_connector *connector)
+{
+}
+EXPORT_SYMBOL(drm_connector_unregister);
+/**
+ * drm_connector_unplug_all - unregister connector userspace interfaces
+ * @dev: drm device
+ *
+ * This function unregisters all connector userspace interfaces in sysfs. Should
  * be call when the device is disconnected, e.g. from an usb driver's
-EXPORT_SYMBOL(drm_connector_cleanup);
+ * ->disconnect callback.
  */
 void drm_connector_unplug_all(struct drm_device *dev)
 {
 	struct drm_connector *connector;
 	/* taking the mode config mutex ends up in a clash with sysfs */
+	list_for_each_entry(connector, &dev->mode_config.connector_list, head)
+		drm_connector_unregister(connector);
+}
+EXPORT_SYMBOL(drm_connector_unplug_all);
+/**
+ * drm_bridge_init - initialize a drm transcoder/bridge
+ * @dev: drm device
+ * @bridge: transcoder/bridge to set up
+ * @funcs: bridge function table
+ *
-//   list_for_each_entry(connector, &dev->mode_config.connector_list, head)
+ * Initialises a preallocated bridge. Bridges should be
-//       drm_sysfs_connector_remove(connector);
+ * subclassed as part of driver connector objects.
+ *
  * Returns:
 	drm_modeset_unlock_all(dev);
 	return ret;
+}
 EXPORT_SYMBOL(drm_bridge_init);
+/**
+ * drm_bridge_cleanup - cleans up an initialised bridge
+ * @bridge: bridge to cleanup
+ *
+ * Cleans up the bridge but doesn't free the object.
  */
 void drm_bridge_cleanup(struct drm_bridge *bridge)
+{
 	struct drm_device *dev = bridge->dev;
 	dev->mode_config.num_bridge--;
 	drm_modeset_unlock_all(dev);
+}
 EXPORT_SYMBOL(drm_bridge_cleanup);
+/**
+ * drm_encoder_init - Init a preallocated encoder
+ * @dev: drm device
+ * @encoder: the encoder to init
+ * @funcs: callbacks for this encoder
+ * @encoder_type: user visible type of the encoder
+ *
+ * Initialises a preallocated encoder. Encoder should be
+ * subclassed as part of driver encoder objects.
+ *
+ * Returns:
+ * Zero on success, error code on failure.
  */
 int drm_encoder_init(struct drm_device *dev,
 		      struct drm_encoder *encoder,
 		      const struct drm_encoder_funcs *funcs,
 		      int encoder_type)
 	drm_modeset_lock_all(dev);
 	ret = drm_mode_object_get(dev, &encoder->base, DRM_MODE_OBJECT_ENCODER);
 	if (ret)
-		goto out;
+		goto out_unlock;
+	encoder->dev = dev;
+	encoder->encoder_type = encoder_type;
+	encoder->funcs = funcs;
+	encoder->name = kasprintf(GFP_KERNEL, "%s-%d",
+				  drm_encoder_enum_list[encoder_type].name,
+				  encoder->base.id);
+	if (!encoder->name) {
-	encoder->dev = dev;
+		ret = -ENOMEM;
-	encoder->encoder_type = encoder_type;
+		goto out_put;
-	encoder->funcs = funcs;
+	}
+	list_add_tail(&encoder->head, &dev->mode_config.encoder_list);
+	dev->mode_config.num_encoder++;
 out_put:
-	list_add_tail(&encoder->head, &dev->mode_config.encoder_list);
+	if (ret)
-	dev->mode_config.num_encoder++;
+		drm_mode_object_put(dev, &encoder->base);
+out_unlock:
+	drm_modeset_unlock_all(dev);
+	return ret;
+}
+EXPORT_SYMBOL(drm_encoder_init);
  out:
-	drm_modeset_unlock_all(dev);
+/**
  * drm_encoder_cleanup - cleans up an initialised encoder
-	return ret;
+ * @encoder: encoder to cleanup
+ *
+ * Cleans up the encoder but doesn't free the object.
+ */
-EXPORT_SYMBOL(drm_encoder_init);
+void drm_encoder_cleanup(struct drm_encoder *encoder)
+{
-void drm_encoder_cleanup(struct drm_encoder *encoder)
+	struct drm_device *dev = encoder->dev;
 	drm_modeset_lock_all(dev);
-	struct drm_device *dev = encoder->dev;
+	drm_mode_object_put(dev, &encoder->base);
-	drm_modeset_lock_all(dev);
+	kfree(encoder->name);
-	drm_mode_object_put(dev, &encoder->base);
+	encoder->name = NULL;
 	list_del(&encoder->head);
 	dev->mode_config.num_encoder--;
 	drm_modeset_unlock_all(dev);
+}
 EXPORT_SYMBOL(drm_encoder_cleanup);
 /**
- * drm_plane_init - Initialise a new plane object
+ * drm_universal_plane_init - Initialize a new universal plane object
  * @dev: DRM device
  * @plane: plane object to init
  * @possible_crtcs: bitmask of possible CRTCs
  * @funcs: callbacks for the new plane
  * @formats: array of supported formats (%DRM_FORMAT_*)
  * @format_count: number of elements in @formats
- * @priv: plane is private (hidden from userspace)?
+ * @type: type of plane (overlay, primary, cursor)
+ *
- * Inits a new object created as base part of a driver plane object.
+ * Initializes a plane object of type @type.
  *
- * RETURNS:
+ * Returns:
  * Zero on success, error code on failure.
  */
+	}
 	memcpy(plane->format_types, formats, format_count * sizeof(uint32_t));
 	plane->format_count = format_count;
+	plane->possible_crtcs = possible_crtcs;
-	plane->possible_crtcs = possible_crtcs;
-	/* private planes are not exposed to userspace, but depending on
-	 * display hardware, might be convenient to allow sharing programming
-	 * for the scanout engine with the crtc implementation.
-	 */
+	plane->type = type;
-	if (!priv) {
 		list_add_tail(&plane->head, &dev->mode_config.plane_list);
-		dev->mode_config.num_plane++;
+	dev->mode_config.num_total_plane++;
-	} else {
+	if (plane->type == DRM_PLANE_TYPE_OVERLAY)
+		dev->mode_config.num_overlay_plane++;
+	drm_object_attach_property(&plane->base,
-		INIT_LIST_HEAD(&plane->head);
+				   dev->mode_config.plane_type_property,
 				   plane->type);
  out:
+	drm_modeset_unlock_all(dev);
+	return ret;
+}
+EXPORT_SYMBOL(drm_universal_plane_init);
+/**
+ * drm_plane_init - Initialize a legacy plane
+ * @dev: DRM device
+ * @plane: plane object to init
+ * @possible_crtcs: bitmask of possible CRTCs
+ * @funcs: callbacks for the new plane
+ * @formats: array of supported formats (%DRM_FORMAT_*)
+ * @format_count: number of elements in @formats
+ * @is_primary: plane type (primary vs overlay)
+ *
+ * Legacy API to initialize a DRM plane.
+ *
+ * New drivers should call drm_universal_plane_init() instead.
+ *
+ * Returns:
+ * Zero on success, error code on failure.
+ */
+int drm_plane_init(struct drm_device *dev, struct drm_plane *plane,
+		   unsigned long possible_crtcs,
+		   const struct drm_plane_funcs *funcs,
+		   const uint32_t *formats, uint32_t format_count,
+		   bool is_primary)
+{
+	enum drm_plane_type type;
-	drm_modeset_unlock_all(dev);
+	type = is_primary ? DRM_PLANE_TYPE_PRIMARY : DRM_PLANE_TYPE_OVERLAY;
 	return drm_universal_plane_init(dev, plane, possible_crtcs, funcs,
-	return ret;
+					formats, format_count, type);
+}
 	struct drm_device *dev = plane->dev;
 	drm_modeset_lock_all(dev);
 	kfree(plane->format_types);
-	drm_mode_object_put(dev, &plane->base);
+	drm_mode_object_put(dev, &plane->base);
-	/* if not added to a list, it must be a private plane */
+	BUG_ON(list_empty(&plane->head));
 	if (!list_empty(&plane->head)) {
 		list_del(&plane->head);
-		dev->mode_config.num_plane--;
+	dev->mode_config.num_total_plane--;
+	if (plane->type == DRM_PLANE_TYPE_OVERLAY)
 		dev->mode_config.num_overlay_plane--;
 	drm_modeset_unlock_all(dev);
+}
 EXPORT_SYMBOL(drm_plane_cleanup);
  * 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;
 	ret = plane->funcs->disable_plane(plane);
+	if (ret) {
+		DRM_ERROR("failed to disable plane with busy fb\n");
-	if (ret)
+		return;
-		DRM_ERROR("failed to disable plane with busy fb\n");
+	}
 	/* disconnect the plane from the fb and crtc: */
-	__drm_framebuffer_unreference(plane->fb);
+	__drm_framebuffer_unreference(old_fb);
 	plane->fb = NULL;
 	plane->crtc = NULL;
-}
-EXPORT_SYMBOL(drm_plane_force_disable);
-/**
- * drm_mode_create - create a new display mode
- * @dev: DRM device
- *
- * Create a new drm_display_mode, give it an ID, and return it.
- *
- * RETURNS:
- * Pointer to new mode on success, NULL on error.
- */
-struct drm_display_mode *drm_mode_create(struct drm_device *dev)
-{
-	struct drm_display_mode *nmode;
-	nmode = kzalloc(sizeof(struct drm_display_mode), GFP_KERNEL);
-	if (!nmode)
-		return NULL;
-	if (drm_mode_object_get(dev, &nmode->base, DRM_MODE_OBJECT_MODE)) {
-		kfree(nmode);
-		return NULL;
-	}
-	return nmode;
-}
-EXPORT_SYMBOL(drm_mode_create);
-/**
- * drm_mode_destroy - remove a mode
- * @dev: DRM device
- * @mode: mode to remove
- *
- * Free @mode's unique identifier, then free it.
- */
-void drm_mode_destroy(struct drm_device *dev, struct drm_display_mode *mode)
-{
-	if (!mode)
-		return;
-	drm_mode_object_put(dev, &mode->base);
-	kfree(mode);
+}
-EXPORT_SYMBOL(drm_mode_destroy);
+EXPORT_SYMBOL(drm_plane_force_disable);
 static int drm_mode_create_standard_connector_properties(struct drm_device *dev)
+{
 	struct drm_property *edid;
-	struct drm_property *edid;
+	struct drm_property *dpms;
-	struct drm_property *dpms;
+	struct drm_property *dev_path;
 	dpms = drm_property_create_enum(dev, 0,
 				   "DPMS", drm_dpms_enum_list,
 				   ARRAY_SIZE(drm_dpms_enum_list));
 	dev->mode_config.dpms_property = dpms;
+	dev_path = drm_property_create(dev,
+				       DRM_MODE_PROP_BLOB |
+				       DRM_MODE_PROP_IMMUTABLE,
+				       "PATH", 0);
+	dev->mode_config.path_property = dev_path;
+	return 0;
+}
+static int drm_mode_create_standard_plane_properties(struct drm_device *dev)
+{
+	struct drm_property *type;
+	/*
+	 * Standard properties (apply to all planes)
+	 */
+	type = drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE,
+					"type", drm_plane_type_enum_list,
+					ARRAY_SIZE(drm_plane_type_enum_list));
+	dev->mode_config.plane_type_property = type;
 	return 0;
+}
 	return 0;
+}
 EXPORT_SYMBOL(drm_mode_create_scaling_mode_property);
+/**
+ * drm_mode_create_aspect_ratio_property - create aspect ratio property
+ * @dev: DRM device
+ *
+ * Called by a driver the first time it's needed, must be attached to desired
+ * connectors.
+ *
+ * Returns:
+ * Zero on success, errno on failure.
+ */
+int drm_mode_create_aspect_ratio_property(struct drm_device *dev)
+{
+	if (dev->mode_config.aspect_ratio_property)
+		return 0;
+	dev->mode_config.aspect_ratio_property =
+		drm_property_create_enum(dev, 0, "aspect ratio",
+				drm_aspect_ratio_enum_list,
+				ARRAY_SIZE(drm_aspect_ratio_enum_list));
+	if (dev->mode_config.aspect_ratio_property == NULL)
+		return -ENOMEM;
+	return 0;
+}
+EXPORT_SYMBOL(drm_mode_create_aspect_ratio_property);
 /**
  * drm_mode_create_dirty_property - create dirty property
  * @dev: DRM device
+ *
  * Called by a driver the first time it's needed, must be attached to desired
 	group->num_encoders = 0;
 	group->num_bridges = 0;
 	return 0;
+}
+void drm_mode_group_destroy(struct drm_mode_group *group)
+{
+	kfree(group->id_list);
+	group->id_list = NULL;
+}
+/*
+ * NOTE: Driver's shouldn't ever call drm_mode_group_init_legacy_group - it is
+ * the drm core's responsibility to set up mode control groups.
  */
 int drm_mode_group_init_legacy_group(struct drm_device *dev,
 				     struct drm_mode_group *group)
+{
 	struct drm_crtc *crtc;
 	return 0;
+}
+EXPORT_SYMBOL(drm_mode_group_init_legacy_group);
+void drm_reinit_primary_mode_group(struct drm_device *dev)
+{
+	drm_modeset_lock_all(dev);
+	drm_mode_group_destroy(&dev->primary->mode_group);
+	drm_mode_group_init_legacy_group(dev, &dev->primary->mode_group);
+	drm_modeset_unlock_all(dev);
+}
-EXPORT_SYMBOL(drm_mode_group_init_legacy_group);
+EXPORT_SYMBOL(drm_reinit_primary_mode_group);
 /**
  * drm_crtc_convert_to_umode - convert a drm_display_mode into a modeinfo
  * @out: drm_mode_modeinfo struct to return to the user
  * @in: drm_mode_modeinfo to use
+ *
  * Convert a drm_mode_modeinfo into a drm_display_mode structure to return to
  * the caller.
+ *
- * RETURNS:
+ * Returns:
  * Zero on success, errno on failure.
  */
 static int drm_crtc_convert_umode(struct drm_display_mode *out,
 				  const struct drm_mode_modeinfo *in)
+{
  * 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:
+ * Returns:
  * Zero on success, errno on failure.
  */
 int drm_mode_getresources(struct drm_device *dev, void *data,
 			  struct drm_file *file_priv)
+{
+	}
 	card_res->count_fbs = fb_count;
 	mutex_unlock(&file_priv->fbs_lock);
-	drm_modeset_lock_all(dev);
-	mode_group = &file_priv->master->minor->mode_group;
+	drm_modeset_lock_all(dev);
+	if (!drm_is_primary_client(file_priv)) {
 	if (file_priv->master->minor->type == DRM_MINOR_CONTROL) {
 		mode_group = NULL;
 		list_for_each(lh, &dev->mode_config.crtc_list)
 			crtc_count++;
 		list_for_each(lh, &dev->mode_config.connector_list)
 			connector_count++;
 		list_for_each(lh, &dev->mode_config.encoder_list)
-		list_for_each(lh, &dev->mode_config.encoder_list)
+			encoder_count++;
-			encoder_count++;
+	} else {
 	} else {
 	/* CRTCs */
 	if (card_res->count_crtcs >= crtc_count) {
 		copied = 0;
 		crtc_id = (uint32_t __user *)(unsigned long)card_res->crtc_id_ptr;
-		if (file_priv->master->minor->type == DRM_MINOR_CONTROL) {
+		if (!mode_group) {
 			list_for_each_entry(crtc, &dev->mode_config.crtc_list,
 					    head) {
 				DRM_DEBUG_KMS("[CRTC:%d]\n", crtc->base.id);
 				if (put_user(crtc->base.id, crtc_id + copied)) {
 	/* Encoders */
 	if (card_res->count_encoders >= encoder_count) {
 		copied = 0;
 		encoder_id = (uint32_t __user *)(unsigned long)card_res->encoder_id_ptr;
-		if (file_priv->master->minor->type == DRM_MINOR_CONTROL) {
+		if (!mode_group) {
 			list_for_each_entry(encoder,
 					    &dev->mode_config.encoder_list,
 					    head) {
 				DRM_DEBUG_KMS("[ENCODER:%d:%s]\n", encoder->base.id,
-						drm_get_encoder_name(encoder));
+						encoder->name);
 				if (put_user(encoder->base.id, encoder_id +
 					     copied)) {
 					ret = -EFAULT;
 					goto out;
 	/* Connectors */
 	if (card_res->count_connectors >= connector_count) {
 		copied = 0;
 		connector_id = (uint32_t __user *)(unsigned long)card_res->connector_id_ptr;
-		if (file_priv->master->minor->type == DRM_MINOR_CONTROL) {
+		if (!mode_group) {
 			list_for_each_entry(connector,
 					    &dev->mode_config.connector_list,
 					    head) {
 				DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n",
 					connector->base.id,
-					drm_get_connector_name(connector));
+					connector->name);
 				if (put_user(connector->base.id,
 					     connector_id + copied)) {
 					ret = -EFAULT;
 					goto out;
+ *
  * Construct a CRTC configuration structure to return to the user.
+ *
  * Called by the user via ioctl.
+ *
- * RETURNS:
+ * Returns:
  * Zero on success, 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;
-	struct drm_mode_object *obj;
 	int ret = 0;
 	if (!drm_core_check_feature(dev, DRIVER_MODESET))
 		return -EINVAL;
-	drm_modeset_lock_all(dev);
+	drm_modeset_lock_all(dev);
 	obj = drm_mode_object_find(dev, crtc_resp->crtc_id,
-				   DRM_MODE_OBJECT_CRTC);
+	crtc = drm_crtc_find(dev, crtc_resp->crtc_id);
-	if (!obj) {
+	if (!crtc) {
-		ret = -ENOENT;
-		goto out;
+		ret = -ENOENT;
 		goto out;
 	crtc = obj_to_crtc(obj);
 	crtc_resp->x = crtc->x;
 	crtc_resp->y = crtc->y;
 	crtc_resp->gamma_size = crtc->gamma_size;
-	if (crtc->fb)
+	if (crtc->primary->fb)
+ *
  * Construct a connector configuration structure to return to the user.
+ *
  * Called by the user via ioctl.
+ *
- * RETURNS:
+ * Returns:
  * Zero on success, 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_mode_object *obj;
 	struct drm_connector *connector;
 	struct drm_display_mode *mode;
 	int mode_count = 0;
 	int props_count = 0;
 	int encoders_count = 0;
 	DRM_DEBUG_KMS("[CONNECTOR:%d:?]\n", out_resp->connector_id);
-	mutex_lock(&dev->mode_config.mutex);
+	mutex_lock(&dev->mode_config.mutex);
 	obj = drm_mode_object_find(dev, out_resp->connector_id,
-				   DRM_MODE_OBJECT_CONNECTOR);
+	connector = drm_connector_find(dev, out_resp->connector_id);
-	if (!obj) {
+	if (!connector) {
-		ret = -ENOENT;
-		goto out;
+		ret = -ENOENT;
 		goto out;
 	connector = obj_to_connector(obj);
 	out_resp->connector_type_id = connector->connector_type_id;
 	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);
 	if (connector->encoder)
 		out_resp->encoder_id = connector->encoder->base.id;
 	else
 		out_resp->encoder_id = 0;
+	drm_modeset_unlock(&dev->mode_config.connection_mutex);
 	/*
 	 * This ioctl is called twice, once to determine how much space is
 	 * needed, and the 2nd time to fill it.
 	mutex_unlock(&dev->mode_config.mutex);
 	return ret;
+}
+/**
+ * drm_mode_getencoder - get encoder configuration
+ * @dev: drm device for the ioctl
+ * @data: data pointer for the ioctl
+ * @file_priv: drm file for the ioctl call
+ *
+ * Construct a encoder configuration structure to return to the user.
+ *
+ * Called by the user via ioctl.
+ *
+ * Returns:
  * Zero on success, 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_mode_object *obj;
+	struct drm_mode_get_encoder *enc_resp = data;
 	struct drm_encoder *encoder;
 	int ret = 0;
 	if (!drm_core_check_feature(dev, DRIVER_MODESET))
-		return -EINVAL;
+		return -EINVAL;
 	drm_modeset_lock_all(dev);
-	obj = drm_mode_object_find(dev, enc_resp->encoder_id,
+	drm_modeset_lock_all(dev);
-				   DRM_MODE_OBJECT_ENCODER);
+	encoder = drm_encoder_find(dev, enc_resp->encoder_id);
-	if (!obj) {
-		ret = -ENOENT;
+	if (!encoder) {
-		goto out;
+		ret = -ENOENT;
 		goto out;
 	encoder = obj_to_encoder(obj);
 	drm_modeset_unlock_all(dev);
 	return ret;
+}
 /**
- * drm_mode_getplane_res - get plane info
+ * drm_mode_getplane_res - enumerate all plane resources
  * @dev: DRM device
  * @data: ioctl data
  * @file_priv: DRM file info
+ *
+ * Construct a list of plane ids to return to the user.
+ *
+ * Called by the user via ioctl.
+ *
- *
+ * Returns:
- * Return an plane count and set of IDs.
+ * Zero on success, 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, ret = 0;
+	unsigned num_planes;
 	if (!drm_core_check_feature(dev, DRIVER_MODESET))
 		return -EINVAL;
+	drm_modeset_lock_all(dev);
+	config = &dev->mode_config;
+	if (file_priv->universal_planes)
 		num_planes = config->num_total_plane;
-	drm_modeset_lock_all(dev);
+	else
-	config = &dev->mode_config;
+		num_planes = config->num_overlay_plane;
 	/*
 	 * This ioctl is called twice, once to determine how much space is
 	 * needed, and the 2nd time to fill it.
 	 */
+	if (num_planes &&
+	    (plane_resp->count_planes >= num_planes)) {
+		plane_ptr = (uint32_t __user *)(unsigned long)plane_resp->plane_id_ptr;
+		list_for_each_entry(plane, &config->plane_list, head) {
+			/*
+			 * Unless userspace set the 'universal planes'
+			 * capability bit, only advertise overlays.
-	if (config->num_plane &&
+			 */
-	    (plane_resp->count_planes >= config->num_plane)) {
+			if (plane->type != DRM_PLANE_TYPE_OVERLAY &&
-		plane_ptr = (uint32_t __user *)(unsigned long)plane_resp->plane_id_ptr;
+			    !file_priv->universal_planes)
 				continue;
 		list_for_each_entry(plane, &config->plane_list, head) {
 			if (put_user(plane->base.id, plane_ptr + copied)) {
 				ret = -EFAULT;
 				goto out;
+			}
 			copied++;
+		}
+	}
-	plane_resp->count_planes = config->num_plane;
+	plane_resp->count_planes = num_planes;
 out:
 	drm_modeset_unlock_all(dev);
 	return ret;
+}
+/**
+ * drm_mode_getplane - get plane configuration
+ * @dev: DRM device
-/**
+ * @data: ioctl data
+ * @file_priv: DRM file info
  * drm_mode_getplane - get plane info
- * @dev: DRM device
+ * Construct a plane configuration structure to return to the user.
  * @data: ioctl data
- * @file_priv: DRM file info
+ * Called by the user via ioctl.
+ *
- * Return plane info, including formats supported, gamma size, any
- * current fb, etc.
+ * Returns:
- */
+ * Zero on success, errno on failure.
-int drm_mode_getplane(struct drm_device *dev, void *data,
+ */
-			struct drm_file *file_priv)
+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_mode_object *obj;
+	struct drm_mode_get_plane *plane_resp = data;
-	struct drm_plane *plane;
-	uint32_t __user *format_ptr;
+	struct drm_plane *plane;
-	int ret = 0;
+	uint32_t __user *format_ptr;
 	int ret = 0;
 	if (!drm_core_check_feature(dev, DRIVER_MODESET))
-		return -EINVAL;
 	if (!drm_core_check_feature(dev, DRIVER_MODESET))
-	drm_modeset_lock_all(dev);
+		return -EINVAL;
 	obj = drm_mode_object_find(dev, plane_resp->plane_id,
-				   DRM_MODE_OBJECT_PLANE);
+	drm_modeset_lock_all(dev);
 out:
 	drm_modeset_unlock_all(dev);
 	return ret;
+}
-/**
+/*
- * drm_mode_setplane - set up or tear down an plane
- * @dev: DRM device
- * @data: ioctl data*
- * @file_priv: DRM file info
+ * setplane_internal - setplane handler for internal callers
  *
+ * Note that we assume an extra reference has already been taken on fb.  If the
+ * update fails, this reference will be dropped before return; if it succeeds,
+ * the previous framebuffer (if any) will be unreferenced instead.
- * Set plane info, including placement, fb, scaling, and other factors.
+ *
- * Or pass a NULL fb to disable.
+ * src_{x,y,w,h} are provided in 16.16 fixed point format
  */
+static int setplane_internal(struct drm_plane *plane,
-int drm_mode_setplane(struct drm_device *dev, void *data,
+			     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,
-			struct drm_file *file_priv)
+			     uint32_t src_w, uint32_t src_h)
-{
-	struct drm_mode_set_plane *plane_req = data;
-	struct drm_mode_object *obj;
+{
-	struct drm_plane *plane;
-	struct drm_crtc *crtc;
+	struct drm_device *dev = plane->dev;
-	struct drm_framebuffer *fb = NULL, *old_fb = NULL;
+	struct drm_framebuffer *old_fb = NULL;
 	int ret = 0;
 	unsigned int fb_width, fb_height;
-	int i;
-	if (!drm_core_check_feature(dev, DRIVER_MODESET))
-		return -EINVAL;
-	/*
-	 * 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);
-	if (!obj) {
-		DRM_DEBUG_KMS("Unknown plane ID %d\n",
-			      plane_req->plane_id);
-		return -ENOENT;
-	}
-	plane = obj_to_plane(obj);
+	int i;
 	/* No fb means shut it down */
-	if (!plane_req->fb_id) {
+	if (!fb) {
 		drm_modeset_lock_all(dev);
+		old_fb = plane->fb;
-		old_fb = plane->fb;
+		ret = plane->funcs->disable_plane(plane);
-		plane->funcs->disable_plane(plane);
+		if (!ret) {
 		plane->crtc = NULL;
 		plane->fb = NULL;
-		drm_modeset_unlock_all(dev);
+		} else {
-		goto out;
-	}
-	obj = drm_mode_object_find(dev, plane_req->crtc_id,
-				   DRM_MODE_OBJECT_CRTC);
-	if (!obj) {
+			old_fb = NULL;
-		DRM_DEBUG_KMS("Unknown crtc ID %d\n",
 			      plane_req->crtc_id);
-		ret = -ENOENT;
+		drm_modeset_unlock_all(dev);
-		goto out;
-	}
+		goto out;
-	crtc = obj_to_crtc(obj);
+	}
-	fb = drm_framebuffer_lookup(dev, plane_req->fb_id);
-	if (!fb) {
+	/* Check whether this plane is usable on this CRTC */
-		DRM_DEBUG_KMS("Unknown framebuffer ID %d\n",
+	if (!(plane->possible_crtcs & drm_crtc_mask(crtc))) {
-			      plane_req->fb_id);
+		DRM_DEBUG_KMS("Invalid crtc for plane\n");
-		ret = -ENOENT;
+		ret = -EINVAL;
 		goto out;
 	fb_width = fb->width << 16;
 	fb_height = fb->height << 16;
 	/* Make sure source coordinates are inside the fb. */
-	if (plane_req->src_w > fb_width ||
+	if (src_w > fb_width ||
-	    plane_req->src_x > fb_width - plane_req->src_w ||
+	    src_x > fb_width - src_w ||
-	    plane_req->src_h > fb_height ||
+	    src_h > fb_height ||
-	    plane_req->src_y > fb_height - plane_req->src_h) {
+	    src_y > fb_height - src_h) {
-		DRM_DEBUG_KMS("Invalid source coordinates "
-			      "%u.%06ux%u.%06u+%u.%06u+%u.%06u\n",
+		DRM_DEBUG_KMS("Invalid source coordinates "
-			      plane_req->src_w >> 16,
-			      ((plane_req->src_w & 0xffff) * 15625) >> 10,
+			      "%u.%06ux%u.%06u+%u.%06u+%u.%06u\n",
-			      plane_req->src_h >> 16,
-			      ((plane_req->src_h & 0xffff) * 15625) >> 10,
+			      src_w >> 16, ((src_w & 0xffff) * 15625) >> 10,
-			      plane_req->src_x >> 16,
-			      ((plane_req->src_x & 0xffff) * 15625) >> 10,
+			      src_h >> 16, ((src_h & 0xffff) * 15625) >> 10,
-			      plane_req->src_y >> 16,
+			      src_x >> 16, ((src_x & 0xffff) * 15625) >> 10,
-			      ((plane_req->src_y & 0xffff) * 15625) >> 10);
+			      src_y >> 16, ((src_y & 0xffff) * 15625) >> 10);
 		ret = -ENOSPC;
-		goto out;
-	}
-	/* Give drivers some help against integer overflows */
-	if (plane_req->crtc_w > INT_MAX ||
-	    plane_req->crtc_x > INT_MAX - (int32_t) plane_req->crtc_w ||
-	    plane_req->crtc_h > INT_MAX ||
-	    plane_req->crtc_y > INT_MAX - (int32_t) plane_req->crtc_h) {
-		DRM_DEBUG_KMS("Invalid CRTC coordinates %ux%u+%d+%d\n",
-			      plane_req->crtc_w, plane_req->crtc_h,
-			      plane_req->crtc_x, plane_req->crtc_y);
-		ret = -ERANGE;
 		goto out;
+	}
 	drm_modeset_lock_all(dev);
-	ret = plane->funcs->update_plane(plane, crtc, fb,
-					 plane_req->crtc_x, plane_req->crtc_y,
+	old_fb = plane->fb;
-					 plane_req->crtc_w, plane_req->crtc_h,
+	ret = plane->funcs->update_plane(plane, crtc, fb,
-					 plane_req->src_x, plane_req->src_y,
-					 plane_req->src_w, plane_req->src_h);
+					 crtc_x, crtc_y, crtc_w, crtc_h,
-	if (!ret) {
+					 src_x, src_y, src_w, src_h);
-		old_fb = plane->fb;
+	if (!ret) {
+		plane->crtc = crtc;
+		plane->fb = fb;
-		plane->crtc = crtc;
+		fb = NULL;
-		plane->fb = fb;
+	} else {
-		fb = NULL;
+		old_fb = NULL;
+	}
 	drm_modeset_unlock_all(dev);
 out:
 	if (fb)
+		drm_framebuffer_unreference(fb);
+	if (old_fb)
+		drm_framebuffer_unreference(old_fb);
+	return ret;
+}
+/**
+ * drm_mode_setplane - configure a plane's configuration
+ * @dev: DRM device
+ * @data: ioctl data*
+ * @file_priv: DRM file info
+ *
+ * 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.
+ */
+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;
+	if (!drm_core_check_feature(dev, DRIVER_MODESET))
+		return -EINVAL;
+	/* Give drivers some help against integer overflows */
+	if (plane_req->crtc_w > INT_MAX ||
+	    plane_req->crtc_x > INT_MAX - (int32_t) plane_req->crtc_w ||
+	    plane_req->crtc_h > INT_MAX ||
+	    plane_req->crtc_y > INT_MAX - (int32_t) plane_req->crtc_h) {
+		DRM_DEBUG_KMS("Invalid CRTC coordinates %ux%u+%d+%d\n",
+			      plane_req->crtc_w, plane_req->crtc_h,
+			      plane_req->crtc_x, plane_req->crtc_y);
+		return -ERANGE;
+	}
+	/*
+	 * 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);
+	if (!obj) {
+		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);
+		if (!obj) {
+			DRM_DEBUG_KMS("Unknown crtc ID %d\n",
+				      plane_req->crtc_id);
+			return -ENOENT;
+		}
+		crtc = obj_to_crtc(obj);
+	}
+	/*
+	 * setplane_internal will take care of deref'ing either the old or new
+	 * framebuffer depending on success.
+	 */
-		drm_framebuffer_unreference(fb);
+	return setplane_internal(plane, crtc, fb,
-	if (old_fb)
+				 plane_req->crtc_x, plane_req->crtc_y,
-		drm_framebuffer_unreference(old_fb);
+				 plane_req->crtc_w, plane_req->crtc_h,
 				 plane_req->src_x, plane_req->src_y,
-	return ret;
+				 plane_req->src_w, plane_req->src_h);
+}
 #endif
+/**
+ * drm_mode_set_config_internal - helper to call ->set_config
+ * @set: modeset config to set
 /**
- * drm_mode_set_config_internal - helper to call ->set_config
+ * This is a little helper to wrap internal calls to the ->set_config driver
- * @set: modeset config to set
+ * interface. The only thing it adds is correct refcounting dance.
+ *
- * This is a little helper to wrap internal calls to the ->set_config driver
+ * Returns:
 	 * 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->fb;
+		tmp->old_fb = tmp->primary->fb;
 	fb = set->fb;
 	ret = crtc->funcs->set_config(set);
 	if (ret == 0) {
-		/* crtc->fb must be updated by ->set_config, enforces this. */
+		crtc->primary->crtc = crtc;
-		WARN_ON(fb != crtc->fb);
+		crtc->primary->fb = fb;
 	}
 	list_for_each_entry(tmp, &crtc->dev->mode_config.crtc_list, head) {
-		if (tmp->fb)
+		if (tmp->primary->fb)
-			drm_framebuffer_reference(tmp->fb);
+			drm_framebuffer_reference(tmp->primary->fb);
 //		if (tmp->old_fb)
 //			drm_framebuffer_unreference(tmp->old_fb);
+	}
 	return ret;
 }
 EXPORT_SYMBOL(drm_mode_set_config_internal);
+#if 0
+/**
+ * drm_crtc_check_viewport - Checks that a framebuffer is big enough for the
+ *     CRTC viewport
  * @crtc: CRTC that framebuffer will be displayed on
-#if 0
+ * @x: x panning
-/*
+ * @y: y panning
- * Checks that the framebuffer is big enough for the CRTC viewport
+ * @mode: mode that framebuffer will be displayed under
- * (x, y, hdisplay, vdisplay)
+ * @fb: framebuffer to check size of
  */
 		return -ENOSPC;
+	}
 	return 0;
+}
 EXPORT_SYMBOL(drm_crtc_check_viewport);
 /**
  * drm_mode_setcrtc - set CRTC configuration
+ *
  * Build a new CRTC configuration based on user request.
+ *
  * Called by the user via ioctl.
+ *
- * RETURNS:
+ * Returns:
  * Zero on success, 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;
 	struct drm_mode_crtc *crtc_req = data;
-	struct drm_mode_object *obj;
 	struct drm_crtc *crtc;
 	struct drm_connector **connector_set = NULL, *connector;
 	struct drm_framebuffer *fb = NULL;
 	struct drm_display_mode *mode = NULL;
 	struct drm_mode_set set;
 	/* For some reason crtc x/y offsets are signed internally. */
 	if (crtc_req->x > INT_MAX || crtc_req->y > INT_MAX)
 		return -ERANGE;
 	drm_modeset_lock_all(dev);
-	obj = drm_mode_object_find(dev, crtc_req->crtc_id,
-				   DRM_MODE_OBJECT_CRTC);
+	crtc = drm_crtc_find(dev, crtc_req->crtc_id);
-	if (!obj) {
+	if (!crtc) {
 		DRM_DEBUG_KMS("Unknown CRTC ID %d\n", crtc_req->crtc_id);
 		ret = -ENOENT;
 		goto out;
-	}
 	crtc = obj_to_crtc(obj);
 	DRM_DEBUG_KMS("[CRTC:%d]\n", crtc->base.id);
 	if (crtc_req->mode_valid) {
 		/* If we have a mode we need a framebuffer. */
 		/* If we pass -1, set the mode with the currently bound fb */
 		if (crtc_req->fb_id == -1) {
-			if (!crtc->fb) {
+			if (!crtc->primary->fb) {
 				DRM_DEBUG_KMS("CRTC doesn't have current FB\n");
 				ret = -EINVAL;
 				goto out;
+			}
-					fb = crtc->fb;
+			fb = crtc->primary->fb;
 			/* Make refcounting symmetric with the lookup path. */
 			drm_framebuffer_reference(fb);
 		} else {
 			if (get_user(out_id, &set_connectors_ptr[i])) {
 				ret = -EFAULT;
 				goto out;
+			}
-			obj = drm_mode_object_find(dev, out_id,
-						   DRM_MODE_OBJECT_CONNECTOR);
+			connector = drm_connector_find(dev, out_id);
-			if (!obj) {
+			if (!connector) {
 				DRM_DEBUG_KMS("Connector id %d unknown\n",
 						out_id);
 				ret = -ENOENT;
 				goto out;
-			}
 			connector = obj_to_connector(obj);
 			DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n",
 					connector->base.id,
-					drm_get_connector_name(connector));
+					connector->name);
 			connector_set[i] = connector;
 static int drm_mode_cursor_common(struct drm_device *dev,
 				  struct drm_mode_cursor2 *req,
 				  struct drm_file *file_priv)
-{
 	struct drm_mode_object *obj;
 	struct drm_crtc *crtc;
 	int ret = 0;
 	if (!drm_core_check_feature(dev, DRIVER_MODESET))
 		return -EINVAL;
 	if (!req->flags || (~DRM_MODE_CURSOR_FLAGS & req->flags))
 		return -EINVAL;
-	obj = drm_mode_object_find(dev, req->crtc_id, DRM_MODE_OBJECT_CRTC);
+	crtc = drm_crtc_find(dev, req->crtc_id);
-	if (!obj) {
+	if (!crtc) {
+		DRM_DEBUG_KMS("Unknown CRTC ID %d\n", req->crtc_id);
+		return -ENOENT;
+	}
+	/*
+	 * If this crtc has a universal cursor plane, call that plane's update
-		DRM_DEBUG_KMS("Unknown CRTC ID %d\n", req->crtc_id);
+	 * handler rather than using legacy cursor handlers.
-		return -ENOENT;
+	 */
 	if (crtc->cursor)
-	crtc = obj_to_crtc(obj);
+		return drm_mode_cursor_universal(crtc, req, file_priv);
-	mutex_lock(&crtc->mutex);
+	drm_modeset_lock(&crtc->mutex, NULL);
 			ret = -EFAULT;
 			goto out;
+		}
+	}
 out:
-	mutex_unlock(&crtc->mutex);
+	drm_modeset_unlock(&crtc->mutex);
 	return ret;
+}
+/**
+ * drm_mode_cursor_ioctl - set CRTC's cursor configuration
+ * @dev: drm device for the ioctl
+ * @data: data pointer for the ioctl
+ * @file_priv: drm file for the ioctl call
+ *
+ * Set the cursor configuration based on user request.
+ *
+ * Called by the user via ioctl.
+ *
+ * Returns:
  * Zero on success, errno on failure.
  */
 int drm_mode_cursor_ioctl(struct drm_device *dev,
 			void *data, struct drm_file *file_priv)
+{
 	new_req.hot_x = new_req.hot_y = 0;
 	return drm_mode_cursor_common(dev, &new_req, file_priv);
+}
+/**
+ * drm_mode_cursor2_ioctl - set CRTC's cursor configuration
+ * @dev: drm device for the ioctl
+ * @data: data pointer for the ioctl
+ * @file_priv: drm file for the ioctl call
+ *
+ * Set the cursor configuration based on user request. This implements the 2nd
+ * version of the cursor ioctl, which allows userspace to additionally specify
+ * the hotspot of the pointer.
+ *
+ * Called by the user via ioctl.
+ *
+ * Returns:
  * Zero on success, 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;
 	return drm_mode_cursor_common(dev, req, file_priv);
+}
+#endif
+/**
+ * drm_mode_legacy_fb_format - compute drm fourcc code from legacy description
-}
+ * @bpp: bits per pixels
+ * @depth: bit depth per pixel
+ *
-#endif
+ * Computes a drm fourcc pixel format code for the given @bpp/@depth values.
  * Useful in fbdev emulation code, since that deals in those values.
-/* Original addfb only supported RGB formats, so figure out which one */
+ */
 uint32_t drm_mode_legacy_fb_format(uint32_t bpp, uint32_t depth)
  * drm_mode_addfb - add an FB to the graphics configuration
  * @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.
+ * Add a new FB to the specified CRTC, given a user request. This is the
+ * original addfb ioclt which only supported RGB formats.
+ *
  * Called by the user via ioctl.
+ *
- * RETURNS:
+ * Returns:
  * Zero on success, errno on failure.
  */
 int drm_mode_addfb(struct drm_device *dev,
 		   void *data, struct drm_file *file_priv)
+{
+	}
 	return 0;
-}
+}
-/**
- * drm_mode_addfb2 - add an FB to the graphics configuration
- * @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 with format.
- *
- * Called by the user via ioctl.
- *
- * RETURNS:
- * Zero on success, errno on failure.
- */
+static struct drm_framebuffer *add_framebuffer_internal(struct drm_device *dev,
-int drm_mode_addfb2(struct drm_device *dev,
+							struct drm_mode_fb_cmd2 *r,
-		    void *data, struct drm_file *file_priv)
 							struct drm_file *file_priv)
 	struct drm_mode_fb_cmd2 *r = data;
 	struct drm_mode_config *config = &dev->mode_config;
-	struct drm_framebuffer *fb;
-	int ret;
-	if (!drm_core_check_feature(dev, DRIVER_MODESET))
+	struct drm_framebuffer *fb;
-		return -EINVAL;
+	int ret;
 	if (r->flags & ~DRM_MODE_FB_INTERLACED) {
 		DRM_DEBUG_KMS("bad framebuffer flags 0x%08x\n", r->flags);
-		return -EINVAL;
+		return ERR_PTR(-EINVAL);
+	}
 	if ((config->min_width > r->width) || (r->width > config->max_width)) {
 		DRM_DEBUG_KMS("bad framebuffer width %d, should be >= %d && <= %d\n",
 			  r->width, config->min_width, config->max_width);
-		return -EINVAL;
+		return ERR_PTR(-EINVAL);
 	}
 	if ((config->min_height > r->height) || (r->height > config->max_height)) {
 		DRM_DEBUG_KMS("bad framebuffer height %d, should be >= %d && <= %d\n",
 			  r->height, config->min_height, config->max_height);
-		return -EINVAL;
+		return ERR_PTR(-EINVAL);
+	}
 	ret = framebuffer_check(r);
 	if (ret)
-		return ret;
+		return ERR_PTR(ret);
 	fb = dev->mode_config.funcs->fb_create(dev, file_priv, r);
 	if (IS_ERR(fb)) {
 		DRM_DEBUG_KMS("could not create framebuffer\n");
-		return PTR_ERR(fb);
+		return fb;
+	}
+	mutex_lock(&file_priv->fbs_lock);
+	r->fb_id = fb->base.id;
+	list_add(&fb->filp_head, &file_priv->fbs);
+	DRM_DEBUG_KMS("[FB:%d]\n", fb->base.id);
+	mutex_unlock(&file_priv->fbs_lock);
+	return fb;
+}
+/**
+ * drm_mode_addfb2 - add an FB to the graphics configuration
+ * @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 with format. This is
+ * the 2nd version of the addfb ioctl, which supports multi-planar framebuffers
+ * and uses fourcc codes as pixel format specifiers.
+ *
+ * Called by the user via ioctl.
+ *
+ * Returns:
+ * Zero on success, errno on failure.
+ */
+int drm_mode_addfb2(struct drm_device *dev,
+		    void *data, struct drm_file *file_priv)
+{
-	}
+	struct drm_framebuffer *fb;
-	mutex_lock(&file_priv->fbs_lock);
+	if (!drm_core_check_feature(dev, DRIVER_MODESET))
-	r->fb_id = fb->base.id;
+		return -EINVAL;
 	list_add(&fb->filp_head, &file_priv->fbs);
+ *
  * Remove the FB specified by the user.
+ *
  * Called by the user via ioctl.
+ *
- * RETURNS:
+ * Returns:
  * Zero on success, errno on failure.
  */
 int drm_mode_rmfb(struct drm_device *dev,
 		   void *data, struct drm_file *file_priv)
+{
+ *
  * Lookup the FB given its ID and return info about it.
+ *
  * Called by the user via ioctl.
+ *
- * RETURNS:
+ * Returns:
  * Zero on success, errno on failure.
  */
 int drm_mode_getfb(struct drm_device *dev,
 		   void *data, struct drm_file *file_priv)
+{
 	drm_framebuffer_unreference(fb);
 	return ret;
+}
+/**
+ * drm_mode_dirtyfb_ioctl - flush frontbuffer rendering on an FB
+ * @dev: drm device for the ioctl
+ * @data: data pointer for the ioctl
+ * @file_priv: drm file for the ioctl call
+ *
+ * Lookup the FB and flush out the damaged area supplied by userspace as a clip
+ * rectangle list. Generic userspace which does frontbuffer rendering must call
+ * this ioctl to flush out the changes on manual-update display outputs, e.g.
+ * usb display-link, mipi manual update panels or edp panel self refresh modes.
+ *
+ * Modesetting drivers which always update the frontbuffer do not need to
+ * implement the corresponding ->dirty framebuffer callback.
+ *
+ * Called by the user via ioctl.
+ *
+ * Returns:
  * Zero on success, errno on failure.
  */
 int drm_mode_dirtyfb_ioctl(struct drm_device *dev,
 			   void *data, struct drm_file *file_priv)
+{
+ *
  * Destroy all the FBs associated with @filp.
+ *
  * Called by the user via ioctl.
+ *
- * RETURNS:
+ * Returns:
  * Zero on success, errno on failure.
  */
 void drm_fb_release(struct drm_file *priv)
+{
 	struct drm_device *dev = priv->minor->dev;
 	mutex_unlock(&priv->fbs_lock);
+}
 #endif
+/**
+ * drm_property_create - create a new property type
+ * @dev: drm device
+ * @flags: flags specifying the property type
+ * @name: name of the property
+ * @num_values: number of pre-defined 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.
+ *
+ * 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)
+{
 	struct drm_property *property = NULL;
 	int ret;
+	property = kzalloc(sizeof(struct drm_property), GFP_KERNEL);
+	if (!property)
-	property = kzalloc(sizeof(struct drm_property), GFP_KERNEL);
+		return NULL;
 	if (!property)
-		return NULL;
+	property->dev = dev;
 	if (num_values) {
 		strncpy(property->name, name, DRM_PROP_NAME_LEN);
 		property->name[DRM_PROP_NAME_LEN-1] = '\0';
+	}
+	list_add_tail(&property->head, &dev->mode_config.property_list);
+	WARN_ON(!drm_property_type_valid(property));
 	list_add_tail(&property->head, &dev->mode_config.property_list);
 	return property;
 fail:
 	kfree(property->values);
 	kfree(property);
 	return NULL;
+}
+EXPORT_SYMBOL(drm_property_create);
+/**
+ * drm_property_create_enum - create a new enumeration property type
+ * @dev: drm device
+ * @flags: flags specifying the property type
+ * @name: name of the property
+ * @props: enumeration lists with property values
+ * @num_values: number of pre-defined 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 only allowed to set one of the predefined values for enumeration
+ * properties.
+ *
+ * Returns:
-EXPORT_SYMBOL(drm_property_create);
+ * A pointer to the newly created property on success, NULL on failure.
  */
 struct drm_property *drm_property_create_enum(struct drm_device *dev, int flags,
 					 const char *name,
 					 const struct drm_prop_enum_list *props,
 	return property;
+}
+EXPORT_SYMBOL(drm_property_create_enum);
+/**
+ * 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
+ *
+ * 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.
+ *
+ * Compared to plain enumeration properties userspace is allowed to set any
+ * or'ed together combination of the predefined property bitflag values
+ *
+ * Returns:
-EXPORT_SYMBOL(drm_property_create_enum);
+ * A pointer to the newly created property on success, NULL on failure.
  */
 struct drm_property *drm_property_create_bitmask(struct drm_device *dev,
 					 int flags, const char *name,
+					 const struct drm_prop_enum_list *props,
-					 const struct drm_prop_enum_list *props,
+					 int num_props,
-					 int num_values)
+					 uint64_t supported_bits)
 {
+	struct drm_property *property;
-	struct drm_property *property;
+	int i, ret, index = 0;
-	int i, ret;
+	int num_values = hweight64(supported_bits);
 	flags |= DRM_MODE_PROP_BITMASK;
+	property = drm_property_create(dev, flags, name, num_values);
+	if (!property)
+		return NULL;
+	for (i = 0; i < num_props; i++) {
+		if (!(supported_bits & (1ULL << props[i].type)))
+			continue;
-	property = drm_property_create(dev, flags, name, num_values);
+		if (WARN_ON(index >= num_values)) {
-	if (!property)
+			drm_property_destroy(dev, property);
-		return NULL;
+			return NULL;
+		}
 	for (i = 0; i < num_values; i++) {
-		ret = drm_property_add_enum(property, i,
+		ret = drm_property_add_enum(property, index++,
 	return property;
+}
 EXPORT_SYMBOL(drm_property_create_bitmask);
-struct drm_property *drm_property_create_range(struct drm_device *dev, int flags,
+static struct drm_property *property_create_range(struct drm_device *dev,
-					 const char *name,
+					 int flags, const char *name,
 					 uint64_t min, uint64_t max)
-{
-	struct drm_property *property;
+{
-	flags |= DRM_MODE_PROP_RANGE;
+	struct drm_property *property;
 	property = drm_property_create(dev, flags, name, 2);
 	if (!property)
 		return NULL;
+	property->values[0] = min;
+	property->values[1] = max;
+	return property;
+}
+/**
+ * drm_property_create_range - create a new ranged property type
+ * @dev: drm device
+ * @flags: flags specifying the property type
+ * @name: name of the property
+ * @min: minimum value of the property
+ * @max: maximum value of the property
+ *
+ * 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
+ * inclusive.
+ *
+ * Returns:
+ * A pointer to the newly created property on success, NULL on failure.
+ */
+struct drm_property *drm_property_create_range(struct drm_device *dev, int flags,
+					 const char *name,
-	property->values[0] = min;
+					 uint64_t min, uint64_t max)
+{
+	return property_create_range(dev, DRM_MODE_PROP_RANGE | flags,
+			name, min, max);
+}
+EXPORT_SYMBOL(drm_property_create_range);
+struct drm_property *drm_property_create_signed_range(struct drm_device *dev,
+					 int flags, const char *name,
+					 int64_t min, int64_t max)
+{
+	return property_create_range(dev, DRM_MODE_PROP_SIGNED_RANGE | flags,
+			name, I642U64(min), I642U64(max));
+}
+EXPORT_SYMBOL(drm_property_create_signed_range);
+struct drm_property *drm_property_create_object(struct drm_device *dev,
+					 int flags, const char *name, uint32_t type)
+{
+	struct drm_property *property;
+	flags |= DRM_MODE_PROP_OBJECT;
+	property = drm_property_create(dev, flags, name, 1);
+	if (!property)
+		return NULL;
+	property->values[0] = type;
+	return property;
+}
+EXPORT_SYMBOL(drm_property_create_object);
+/**
+ * drm_property_add_enum - add a possible value to an enumeration property
+ * @property: enumeration property to change
+ * @index: index of the new enumeration
+ * @value: value of the new enumeration
+ * @name: symbolic name of the new enumeration
+ *
+ * This functions adds enumerations to a property.
+ *
-	property->values[1] = max;
+ * It's use is deprecated, drivers should use one of the more specific helpers
  * to directly create the property with all enumerations already attached.
 	return property;
  * Returns:
+ * Zero on success, error code on failure.
-EXPORT_SYMBOL(drm_property_create_range);
+ */
 int drm_property_add_enum(struct drm_property *property, int index,
-int drm_property_add_enum(struct drm_property *property, int index,
+			  uint64_t value, const char *name)
 			  uint64_t value, const char *name)
 	struct drm_property_enum *prop_enum;
 	struct drm_property_enum *prop_enum;
+	if (!(drm_property_type_is(property, DRM_MODE_PROP_ENUM) ||
+			drm_property_type_is(property, DRM_MODE_PROP_BITMASK)))
-	if (!(property->flags & (DRM_MODE_PROP_ENUM | DRM_MODE_PROP_BITMASK)))
+		return -EINVAL;
 		return -EINVAL;
 	/*
-	/*
+	 * Bitmask enum properties have the additional constraint of values
 	list_add_tail(&prop_enum->head, &property->enum_blob_list);
 	return 0;
+}
 EXPORT_SYMBOL(drm_property_add_enum);
+/**
+ * drm_property_destroy - destroy a drm property
+ * @dev: drm device
+ * @property: property to destry
+ *
+ * This function frees a property including any attached resources like
+ * enumeration values.
  */
 void drm_property_destroy(struct drm_device *dev, struct drm_property *property)
+{
 	struct drm_property_enum *prop_enum, *pt;
 	list_del(&property->head);
 	kfree(property);
+}
 EXPORT_SYMBOL(drm_property_destroy);
+/**
+ * drm_object_attach_property - attach a property to a modeset object
+ * @obj: drm modeset object
+ * @property: property to attach
+ * @init_val: initial value of the property
+ *
+ * This attaches the given property to the modeset object with the given initial
+ * value. Currently this function cannot fail since the properties are stored in
+ * a statically sized array.
  */
 void drm_object_attach_property(struct drm_mode_object *obj,
 				struct drm_property *property,
 				uint64_t init_val)
+{
 	obj->properties->values[count] = init_val;
 	obj->properties->count++;
+}
 EXPORT_SYMBOL(drm_object_attach_property);
+/**
+ * drm_object_property_set_value - set the value of a property
+ * @obj: drm mode object to set property value for
+ * @property: property to set
+ * @val: value the property should be set to
+ *
+ * This functions sets a given property on a given object. This function only
+ * changes the software state of the property, it does not call into the
+ * driver's ->set_property callback.
+ *
+ * Returns:
+ * Zero on success, error code on failure.
  */
 int drm_object_property_set_value(struct drm_mode_object *obj,
 				  struct drm_property *property, uint64_t val)
+{
 		return -EINVAL;
+}
+EXPORT_SYMBOL(drm_object_property_set_value);
+/**
+ * drm_object_property_get_value - retrieve the value of a property
+ * @obj: drm mode object to get property value from
+ * @property: property to retrieve
+ * @val: storage for the property value
+ *
+ * This function retrieves the softare state of the given property for the given
+ * property. Since there is no driver callback to retrieve the current property
+ * value this might be out of sync with the hardware, depending upon the driver
+ * and property.
+ *
+ * Returns:
-EXPORT_SYMBOL(drm_object_property_set_value);
+ * Zero on success, error code on failure.
  */
 int drm_object_property_get_value(struct drm_mode_object *obj,
 				  struct drm_property *property, uint64_t *val)
 		return -EINVAL;
+}
 EXPORT_SYMBOL(drm_object_property_get_value);
+#if 0
+/**
+ * drm_mode_getproperty_ioctl - get the current value of a connector's property
+ * @dev: DRM device
+ * @data: ioctl data
+ * @file_priv: DRM file info
+ *
+ * This function retrieves the current value for an connectors's property.
+ *
+ * Called by the user via ioctl.
+ *
+ * Returns:
+ * Zero on success, errno on failure.
-#if 0
+ */
 int drm_mode_getproperty_ioctl(struct drm_device *dev,
 			       void *data, struct drm_file *file_priv)
-{
 	struct drm_mode_object *obj;
 	struct drm_mode_get_property *out_resp = data;
 	struct drm_property *property;
 	int enum_count = 0;
 	int blob_count = 0;
 	if (!drm_core_check_feature(dev, DRIVER_MODESET))
 		return -EINVAL;
 	drm_modeset_lock_all(dev);
-	obj = drm_mode_object_find(dev, out_resp->prop_id, DRM_MODE_OBJECT_PROPERTY);
+	property = drm_property_find(dev, out_resp->prop_id);
-	if (!obj) {
+	if (!property) {
 		ret = -ENOENT;
-		goto done;
+		goto done;
 	}
 	property = obj_to_property(obj);
 	if (drm_property_type_is(property, DRM_MODE_PROP_ENUM) ||
-	if (property->flags & (DRM_MODE_PROP_ENUM | DRM_MODE_PROP_BITMASK)) {
+			drm_property_type_is(property, DRM_MODE_PROP_BITMASK)) {
 		list_for_each_entry(prop_enum, &property->enum_blob_list, head)
 			enum_count++;
-	} else if (property->flags & DRM_MODE_PROP_BLOB) {
+	} else if (drm_property_type_is(property, DRM_MODE_PROP_BLOB)) {
 		list_for_each_entry(prop_blob, &property->enum_blob_list, head)
+			}
+		}
+	}
 	out_resp->count_values = value_count;
+	if (drm_property_type_is(property, DRM_MODE_PROP_ENUM) ||
-	if (property->flags & (DRM_MODE_PROP_ENUM | DRM_MODE_PROP_BITMASK)) {
+			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;
+			}
+		}
 		out_resp->count_enum_blobs = enum_count;
+	}
-	if (property->flags & DRM_MODE_PROP_BLOB) {
+	if (drm_property_type_is(property, DRM_MODE_PROP_BLOB)) {
 		if ((out_resp->count_enum_blobs >= blob_count) && blob_count) {
 			copied = 0;
 			blob_id_ptr = (uint32_t __user *)(unsigned long)out_resp->enum_blob_ptr;
 	list_del(&blob->head);
 	kfree(blob);
+}
+#if 0
+/**
+ * drm_mode_getblob_ioctl - get the contents of a blob property value
+ * @dev: DRM device
+ * @data: ioctl data
+ * @file_priv: DRM file info
+ *
+ * This function retrieves the contents of a blob property. The value stored in
+ * 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.
-#if 0
+ */
 int drm_mode_getblob_ioctl(struct drm_device *dev,
 			   void *data, struct drm_file *file_priv)
-{
 	struct drm_mode_object *obj;
 	struct drm_mode_get_blob *out_resp = data;
 	struct drm_property_blob *blob;
 	int ret = 0;
 	void __user *blob_ptr;
 	if (!drm_core_check_feature(dev, DRIVER_MODESET))
 		return -EINVAL;
 	drm_modeset_lock_all(dev);
-	obj = drm_mode_object_find(dev, out_resp->blob_id, DRM_MODE_OBJECT_BLOB);
+	blob = drm_property_blob_find(dev, out_resp->blob_id);
-	if (!obj) {
+	if (!blob) {
-		ret = -ENOENT;
-		goto done;
+		ret = -ENOENT;
 		goto done;
 	blob = obj_to_blob(obj);
 	drm_modeset_unlock_all(dev);
 	return ret;
+}
 #endif
+int drm_mode_connector_set_path_property(struct drm_connector *connector,
+					 char *path)
+{
+	struct drm_device *dev = connector->dev;
+	int ret, size;
+	size = strlen(path) + 1;
+	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);
+	return ret;
+}
+EXPORT_SYMBOL(drm_mode_connector_set_path_property);
+/**
+ * drm_mode_connector_update_edid_property - update the edid property of a connector
+ * @connector: drm connector
+ * @edid: new value of the edid property
+ *
+ * This function creates a new blob modeset object and assigns its id to the
+ * connector's edid property.
+ *
+ * Returns:
+ * Zero on success, errno on failure.
  */
 int drm_mode_connector_update_edid_property(struct drm_connector *connector,
 					    struct edid *edid)
+{
 	struct drm_device *dev = connector->dev;
+	int ret, size;
+	/* ignore requests to set edid when overridden */
+	if (connector->override_edid)
-	int ret, size;
+		return 0;
 	if (connector->edid_blob_ptr)
 		drm_property_destroy_blob(dev, connector->edid_blob_ptr);
 		drm_object_property_set_value(obj, property, value);
 	return ret;
+}
+/**
+ * drm_mode_getproperty_ioctl - get the current value of a object's property
+ * @dev: DRM device
+ * @data: ioctl data
+ * @file_priv: DRM file info
+ *
+ * This function retrieves the current value for an object's property. Compared
+ * to the connector specific ioctl this one is extended to also work on crtc and
+ * plane objects.
+ *
+ * Called by the user via ioctl.
+ *
+ * Returns:
  * Zero on success, errno on failure.
  */
 int drm_mode_obj_get_properties_ioctl(struct drm_device *dev, void *data,
 				      struct drm_file *file_priv)
+{
 out:
 	drm_modeset_unlock_all(dev);
 	return ret;
+}
+/**
+ * drm_mode_obj_set_property_ioctl - set the current value of an object's property
+ * @dev: DRM device
+ * @data: ioctl data
+ * @file_priv: DRM file info
+ *
+ * This function sets the current value for an object's property. It also calls
+ * into a driver's ->set_property callback to update the hardware state.
+ * Compared to the connector specific ioctl this one is extended to also work on
+ * crtc and plane objects.
+ *
+ * Called by the user via ioctl.
+ *
+ * Returns:
+ * Zero on success, 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;
 	drm_modeset_unlock_all(dev);
 	return ret;
+}
 #endif
+/**
+ * drm_mode_connector_attach_encoder - attach a connector to an encoder
+ * @connector: connector to attach
+ * @encoder: encoder to attach @connector to
+ *
+ * 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.
  */
 int drm_mode_connector_attach_encoder(struct drm_connector *connector,
 				      struct drm_encoder *encoder)
+{
+	}
 	return -ENOMEM;
+}
 EXPORT_SYMBOL(drm_mode_connector_attach_encoder);
+/**
-void drm_mode_connector_detach_encoder(struct drm_connector *connector,
+ * drm_mode_crtc_set_gamma_size - set the gamma table size
+ * @crtc: CRTC to set the gamma table size for
-				    struct drm_encoder *encoder)
+ * @gamma_size: size of the gamma table
-{
-	int i;
+ *
-	for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
+ * Drivers which support gamma tables should set this to the supported gamma
-		if (connector->encoder_ids[i] == encoder->base.id) {
-			connector->encoder_ids[i] = 0;
-			if (connector->encoder == encoder)
+ * table size when initializing the CRTC. Currently the drm core only supports a
-				connector->encoder = NULL;
-			break;
-		}
+ * fixed gamma table size.
-	}
+ *
-}
+ * Returns:
-EXPORT_SYMBOL(drm_mode_connector_detach_encoder);
+ * Zero on success, errno on failure.
  */
 int drm_mode_crtc_set_gamma_size(struct drm_crtc *crtc,
 				  int gamma_size)
+{
 	return 0;
+}
 EXPORT_SYMBOL(drm_mode_crtc_set_gamma_size);
+#if 0
+/**
+ * drm_mode_gamma_set_ioctl - set the gamma table
+ * @dev: DRM device
+ * @data: ioctl data
+ * @file_priv: DRM file info
+ *
+ * Set the gamma table of a CRTC to the one passed in by the user. Userspace can
+ * 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.
-#if 0
+ */
 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;
-	struct drm_mode_object *obj;
+	struct drm_mode_crtc_lut *crtc_lut = data;
 	struct drm_crtc *crtc;
 	void *r_base, *g_base, *b_base;
 	int size;
 	int ret = 0;
 	if (!drm_core_check_feature(dev, DRIVER_MODESET))
 		return -EINVAL;
 	drm_modeset_lock_all(dev);
-	obj = drm_mode_object_find(dev, crtc_lut->crtc_id, DRM_MODE_OBJECT_CRTC);
+	crtc = drm_crtc_find(dev, crtc_lut->crtc_id);
-	if (!obj) {
+	if (!crtc) {
-		ret = -ENOENT;
-		goto out;
+		ret = -ENOENT;
 		goto out;
 	crtc = obj_to_crtc(obj);
 	drm_modeset_unlock_all(dev);
 	return ret;
+}
+/**
+ * drm_mode_gamma_get_ioctl - get the gamma table
+ * @dev: DRM device
+ * @data: ioctl data
+ * @file_priv: DRM file info
+ *
+ * Copy the current gamma table into the storage provided. This also provides
+ * the gamma table size the driver expects, which can be used to size the
+ * allocated storage.
+ *
+ * Called by the user via ioctl.
+ *
+ * Returns:
  * Zero on success, 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;
-	struct drm_mode_object *obj;
+	struct drm_mode_crtc_lut *crtc_lut = data;
 	struct drm_crtc *crtc;
 	void *r_base, *g_base, *b_base;
 	int size;
 	int ret = 0;
 	if (!drm_core_check_feature(dev, DRIVER_MODESET))
 		return -EINVAL;
 	drm_modeset_lock_all(dev);
-	obj = drm_mode_object_find(dev, crtc_lut->crtc_id, DRM_MODE_OBJECT_CRTC);
+	crtc = drm_crtc_find(dev, crtc_lut->crtc_id);
-	if (!obj) {
-		ret = -ENOENT;
+	if (!crtc) {
-		goto out;
+		ret = -ENOENT;
 		goto out;
 	crtc = obj_to_crtc(obj);
+}
+#endif
+/**
+ * drm_mode_config_reset - call ->reset callbacks
+ * @dev: drm device
+ *
+ * This functions calls all the crtc's, encoder's and connector's ->reset
-#endif
+ * 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)
+{
 /**
  * drm_format_num_planes - get the number of planes for format
  * @format: pixel format (DRM_FORMAT_*)
  *
- * RETURNS:
+ * Returns:
  * The number of planes used by the specified pixel format.
  */
 int drm_format_num_planes(uint32_t format)
+{
 /**
  * drm_format_plane_cpp - determine the bytes per pixel value
  * @format: pixel format (DRM_FORMAT_*)
  * @plane: plane index
+ *
- * RETURNS:
+ * Returns:
  * The bytes per pixel value for the specified plane.
  */
 int drm_format_plane_cpp(uint32_t format, int plane)
+{
 	unsigned int depth;
 /**
  * drm_format_horz_chroma_subsampling - get the horizontal chroma subsampling factor
  * @format: pixel format (DRM_FORMAT_*)
  *
- * RETURNS:
+ * Returns:
  * The horizontal chroma subsampling factor for the
  * specified pixel format.
  */
 int drm_format_horz_chroma_subsampling(uint32_t format)
 /**
  * drm_format_vert_chroma_subsampling - get the vertical chroma subsampling factor
  * @format: pixel format (DRM_FORMAT_*)
  *
- * RETURNS:
+ * Returns:
  * The vertical chroma subsampling factor for the
  * specified pixel format.
  */
 int drm_format_vert_chroma_subsampling(uint32_t format)
+ *
  */
 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);
 	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.plane_list);
 	idr_init(&dev->mode_config.crtc_idr);
 	drm_modeset_lock_all(dev);
+	drm_mode_create_standard_connector_properties(dev);
-	drm_mode_create_standard_connector_properties(dev);
+	drm_mode_create_standard_plane_properties(dev);
 	drm_modeset_unlock_all(dev);
 	/* Just to be sure */
 	dev->mode_config.num_fb = 0;
 	dev->mode_config.num_connector = 0;
+	dev->mode_config.num_crtc = 0;
+	dev->mode_config.num_encoder = 0;
-	dev->mode_config.num_crtc = 0;
+	dev->mode_config.num_overlay_plane = 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.

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/drm_crtc.c – Rev 4560 → 5060