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

 #include
 #include
 #include
 #include
 #include
+#include
 #include "drm_crtc_internal.h"
+#include "drm_internal.h"
-#include "drm_internal.h"
 static struct drm_framebuffer *
-static struct drm_framebuffer *add_framebuffer_internal(struct drm_device *dev,
+internal_framebuffer_create(struct drm_device *dev,
-							struct drm_mode_fb_cmd2 *r,
+			    struct drm_mode_fb_cmd2 *r,
-							struct drm_file *file_priv);
+			    struct drm_file *file_priv);
+	}
 /*
  * Global properties
  */
-static const struct drm_prop_enum_list drm_dpms_enum_list[] =
+static const struct drm_prop_enum_list drm_dpms_enum_list[] = {
-{	{ DRM_MODE_DPMS_ON, "On" },
+	{ DRM_MODE_DPMS_ON, "On" },
 	{ DRM_MODE_DPMS_STANDBY, "Standby" },
 	{ DRM_MODE_DPMS_SUSPEND, "Suspend" },
 	{ DRM_MODE_DPMS_OFF, "Off" }
 };
-DRM_ENUM_NAME_FN(drm_get_dpms_name, drm_dpms_enum_list)
 DRM_ENUM_NAME_FN(drm_get_dpms_name, drm_dpms_enum_list)
 static const struct drm_prop_enum_list drm_plane_type_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" },
 };
-/*
- * Optional properties
+/*
- */
+ * Optional properties
-static const struct drm_prop_enum_list drm_scaling_mode_enum_list[] =
+ */
 static const struct drm_prop_enum_list drm_scaling_mode_enum_list[] = {
 	{ DRM_MODE_SCALE_NONE, "None" },
 };
 /*
  * Non-global properties, but "required" for certain connectors.
  */
-static const struct drm_prop_enum_list drm_dvi_i_select_enum_list[] =
 static const struct drm_prop_enum_list drm_dvi_i_select_enum_list[] = {
 	{ DRM_MODE_SUBCONNECTOR_Automatic, "Automatic" }, /* DVI-I and TV-out */
 	{ DRM_MODE_SUBCONNECTOR_DVID,      "DVI-D"     }, /* DVI-I  */
 	{ DRM_MODE_SUBCONNECTOR_DVIA,      "DVI-A"     }, /* DVI-I  */
 };
-DRM_ENUM_NAME_FN(drm_get_dvi_i_select_name, drm_dvi_i_select_enum_list)
 DRM_ENUM_NAME_FN(drm_get_dvi_i_select_name, drm_dvi_i_select_enum_list)
 static const struct drm_prop_enum_list drm_dvi_i_subconnector_enum_list[] =
 static const struct drm_prop_enum_list drm_dvi_i_subconnector_enum_list[] = {
 	{ DRM_MODE_SUBCONNECTOR_Unknown,   "Unknown"   }, /* DVI-I and TV-out */
 	{ DRM_MODE_SUBCONNECTOR_DVID,      "DVI-D"     }, /* DVI-I  */
 	{ DRM_MODE_SUBCONNECTOR_DVIA,      "DVI-A"     }, /* DVI-I  */
 };
 DRM_ENUM_NAME_FN(drm_get_dvi_i_subconnector_name,
-		 drm_dvi_i_subconnector_enum_list)
+DRM_ENUM_NAME_FN(drm_get_dvi_i_subconnector_name,
 		 drm_dvi_i_subconnector_enum_list)
 static const struct drm_prop_enum_list drm_tv_select_enum_list[] =
 static const struct drm_prop_enum_list drm_tv_select_enum_list[] = {
 	{ DRM_MODE_SUBCONNECTOR_Automatic, "Automatic" }, /* DVI-I and TV-out */
 	{ DRM_MODE_SUBCONNECTOR_Composite, "Composite" }, /* TV-out */
 	{ DRM_MODE_SUBCONNECTOR_SVIDEO,    "SVIDEO"    }, /* TV-out */
-	{ DRM_MODE_SUBCONNECTOR_Component, "Component" }, /* TV-out */
-	{ DRM_MODE_SUBCONNECTOR_SCART,     "SCART"     }, /* TV-out */
+	{ DRM_MODE_SUBCONNECTOR_Component, "Component" }, /* TV-out */
-};
+	{ DRM_MODE_SUBCONNECTOR_SCART,     "SCART"     }, /* TV-out */
 };
 DRM_ENUM_NAME_FN(drm_get_tv_select_name, drm_tv_select_enum_list)
 DRM_ENUM_NAME_FN(drm_get_tv_select_name, drm_tv_select_enum_list)
 };
 /*
  * Connector and encoder types.
  */
-static struct drm_conn_prop_enum_list drm_connector_enum_list[] =
+static struct drm_conn_prop_enum_list drm_connector_enum_list[] = {
-{	{ DRM_MODE_CONNECTOR_Unknown, "Unknown" },
+	{ DRM_MODE_CONNECTOR_Unknown, "Unknown" },
 	{ DRM_MODE_CONNECTOR_VGA, "VGA" },
 	{ DRM_MODE_CONNECTOR_DVII, "DVI-I" },
 	{ DRM_MODE_CONNECTOR_DVID, "DVI-D" },
 	{ DRM_MODE_CONNECTOR_DVIA, "DVI-A" },
 	{ DRM_MODE_CONNECTOR_eDP, "eDP" },
 	{ DRM_MODE_CONNECTOR_VIRTUAL, "Virtual" },
 	{ DRM_MODE_CONNECTOR_DSI, "DSI" },
 };
-static const struct drm_prop_enum_list drm_encoder_enum_list[] =
+static const struct drm_prop_enum_list drm_encoder_enum_list[] = {
-{	{ DRM_MODE_ENCODER_NONE, "None" },
+	{ DRM_MODE_ENCODER_NONE, "None" },
 	{ DRM_MODE_ENCODER_DAC, "DAC" },
 	{ 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[] =
 static const struct drm_prop_enum_list drm_subpixel_enum_list[] = {
 	{ SubPixelUnknown, "Unknown" },
 	{ SubPixelHorizontalRGB, "Horizontal RGB" },
 	{ SubPixelHorizontalBGR, "Horizontal BGR" },
  * 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
+ * Zero on success, error code on failure.
- * object.
  */
 int drm_mode_object_get(struct drm_device *dev,
-			       struct drm_mode_object *obj, uint32_t obj_type)
+			struct drm_mode_object *obj, uint32_t obj_type)
+{
 	return drm_mode_object_get_reg(dev, obj, obj_type, true);
 	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 &&
-	if (obj && (obj->type == DRM_MODE_OBJECT_FB))
+	    (obj->type == DRM_MODE_OBJECT_FB ||
+	     obj->type == DRM_MODE_OBJECT_BLOB))
 		obj = NULL;
 	mutex_unlock(&dev->mode_config.idr_mutex);
 	return obj;
+{
 	struct drm_mode_object *obj = NULL;
 	/* Framebuffers are reference counted and need their own lookup
 	 * function.*/
-	WARN_ON(type == DRM_MODE_OBJECT_FB);
+	WARN_ON(type == DRM_MODE_OBJECT_FB || type == DRM_MODE_OBJECT_BLOB);
 	obj = _object_find(dev, id, type);
 	return obj;
+}
 	dev->mode_config.num_fb++;
 	list_add(&fb->head, &dev->mode_config.fb_list);
 out:
 	mutex_unlock(&dev->mode_config.fb_lock);
-	return 0;
+	return ret;
+}
 EXPORT_SYMBOL(drm_framebuffer_init);
+{
 	struct drm_framebuffer *fb;
 	mutex_lock(&dev->mode_config.fb_lock);
 	fb = __drm_framebuffer_lookup(dev, id);
-	if (fb)
+	if (fb) {
+		if (!kref_get_unless_zero(&fb->refcount))
+			fb = NULL;
 		drm_framebuffer_reference(fb);
 	mutex_unlock(&dev->mode_config.fb_lock);
 	return fb;
 	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);
-static void drm_framebuffer_free_bug(struct kref *kref)
-{
-	BUG();
-}
-static void __drm_framebuffer_unreference(struct drm_framebuffer *fb)
-{
-	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_unregister_private - unregister a private fb from the lookup idr
  * @fb: fb to unregister
+ *
  * i.e. the object may not be destroyed through this call (since it'll lead to a
  * locking inversion).
  */
 void drm_framebuffer_unregister_private(struct drm_framebuffer *fb)
+{
-	struct drm_device *dev = fb->dev;
+	struct drm_device *dev;
+	if (!fb)
+		return;
+	dev = fb->dev;
 	mutex_lock(&dev->mode_config.fb_lock);
 	/* Mark fb as reaped and drop idr ref. */
 	__drm_framebuffer_unregister(dev, fb);
  * last reference to the framebuffer. It is also guaranteed to not take the
  * modeset locks in this case.
  */
 void drm_framebuffer_remove(struct drm_framebuffer *fb)
+{
-	struct drm_device *dev = fb->dev;
+	struct drm_device *dev;
 	struct drm_crtc *crtc;
 	struct drm_plane *plane;
 	struct drm_mode_set set;
 	int ret;
+	if (!fb)
+		return;
+	dev = fb->dev;
 	WARN_ON(!list_empty(&fb->filp_head));
 	/*
 	 * in this manner.
 	 */
 	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) {
+		drm_for_each_crtc(crtc, dev) {
 			if (crtc->primary->fb == fb) {
 				/* should turn off the crtc */
 				memset(&set, 0, sizeof(struct drm_mode_set));
 				set.crtc = crtc;
 				set.fb = NULL;
 				if (ret)
 					DRM_ERROR("failed to reset crtc %p when fb was deleted\n", crtc);
+			}
+		}
-		list_for_each_entry(plane, &dev->mode_config.plane_list, head) {
+		drm_for_each_plane(plane, dev) {
 			if (plane->fb == fb)
 				drm_plane_force_disable(plane);
+		}
 		drm_modeset_unlock_all(dev);
-		   const struct drm_crtc_funcs *funcs)
+			      const struct drm_crtc_funcs *funcs)
+{
 	struct drm_mode_config *config = &dev->mode_config;
 	int ret;
+	WARN_ON(primary && primary->type != DRM_PLANE_TYPE_PRIMARY);
+	WARN_ON(cursor && cursor->type != DRM_PLANE_TYPE_CURSOR);
 	crtc->dev = dev;
-	crtc->funcs = funcs;
-	crtc->invert_dimensions = false;
+	crtc->funcs = funcs;
 	drm_modeset_lock_init(&crtc->mutex);
 	ret = drm_mode_object_get(dev, &crtc->base, DRM_MODE_OBJECT_CRTC);
 	if (primary)
 		primary->possible_crtcs = 1 << drm_crtc_index(crtc);
 	if (cursor)
 		cursor->possible_crtcs = 1 << drm_crtc_index(crtc);
+	if (drm_core_check_feature(dev, DRIVER_ATOMIC)) {
+		drm_object_attach_property(&crtc->base, config->prop_active, 0);
+		drm_object_attach_property(&crtc->base, config->prop_mode_id, 0);
+	}
 	return 0;
+}
 EXPORT_SYMBOL(drm_crtc_init_with_planes);
 unsigned int drm_crtc_index(struct drm_crtc *crtc)
+{
 	unsigned int index = 0;
 	struct drm_crtc *tmp;
-	list_for_each_entry(tmp, &crtc->dev->mode_config.crtc_list, head) {
+	drm_for_each_crtc(tmp, crtc->dev) {
 		if (tmp == crtc)
 			return index;
 	list_del(&mode->head);
 	drm_mode_destroy(connector->dev, mode);
+}
+/**
+ * drm_display_info_set_bus_formats - set the supported bus formats
+ * @info: display info to store bus formats in
+ * @formats: array containing the supported bus formats
+ * @num_formats: the number of entries in the fmts array
+ *
+ * Store the supported bus formats in display info structure.
+ * See MEDIA_BUS_FMT_* definitions in include/uapi/linux/media-bus-format.h for
+ * a full list of available formats.
+ */
+int drm_display_info_set_bus_formats(struct drm_display_info *info,
+				     const u32 *formats,
+				     unsigned int num_formats)
+{
+	u32 *fmts = NULL;
+	if (!formats && num_formats)
+		return -EINVAL;
+	if (formats && num_formats) {
+		fmts = kmemdup(formats, sizeof(*formats) * num_formats,
+			       GFP_KERNEL);
+		if (!fmts)
+			return -ENOMEM;
+	}
+	kfree(info->bus_formats);
+	info->bus_formats = fmts;
+	info->num_bus_formats = num_formats;
+	return 0;
+}
+EXPORT_SYMBOL(drm_display_info_set_bus_formats);
+/**
+ * drm_connector_get_cmdline_mode - reads the user's cmdline mode
+ * @connector: connector to quwery
+ *
+ * The kernel supports per-connector configration of its consoles through
+ * use of the video= parameter. This function parses that option and
+ * extracts the user's specified mode (or enable/disable status) for a
+ * particular connector. This is typically only used during the early fbdev
+ * setup.
+ */
+static void drm_connector_get_cmdline_mode(struct drm_connector *connector)
+{
+	struct drm_cmdline_mode *mode = &connector->cmdline_mode;
+	char *option = NULL;
+    return;
+#if 0
+	if (fb_get_options(connector->name, &option))
+		return;
+	if (!drm_mode_parse_command_line_for_connector(option,
+						       connector,
+						       mode))
+		return;
+	if (mode->force) {
+		const char *s;
+		switch (mode->force) {
+		case DRM_FORCE_OFF:
+			s = "OFF";
+			break;
+		case DRM_FORCE_ON_DIGITAL:
+			s = "ON - dig";
+			break;
+		default:
+		case DRM_FORCE_ON:
+			s = "ON";
+			break;
+		}
+		DRM_INFO("forcing %s connector %s\n", connector->name, s);
+		connector->force = mode->force;
+	}
+	DRM_DEBUG_KMS("cmdline mode for connector %s %dx%d@%dHz%s%s%s\n",
+		      connector->name,
+		      mode->xres, mode->yres,
+		      mode->refresh_specified ? mode->refresh : 60,
+		      mode->rb ? " reduced blanking" : "",
+		      mode->margins ? " with margins" : "",
+		      mode->interlace ?  " interlaced" : "");
+#endif
+}
 /**
  * drm_connector_init - Init a preallocated connector
  * @dev: DRM device
  * @connector: the connector to init
  * @funcs: callbacks for this connector
 int drm_connector_init(struct drm_device *dev,
-		     struct drm_connector *connector,
+		       struct drm_connector *connector,
-		     const struct drm_connector_funcs *funcs,
+		       const struct drm_connector_funcs *funcs,
-		     int connector_type)
+		       int connector_type)
+{
+	struct drm_mode_config *config = &dev->mode_config;
 	int ret;
 	struct ida *connector_ida =
 		&drm_connector_enum_list[connector_type].ida;
 	INIT_LIST_HEAD(&connector->probed_modes);
 	INIT_LIST_HEAD(&connector->modes);
 	connector->edid_blob_ptr = NULL;
 	connector->status = connector_status_unknown;
+	drm_connector_get_cmdline_mode(connector);
+	/* We should add connectors at the end to avoid upsetting the connector
+	 * index too much. */
-	list_add_tail(&connector->head, &dev->mode_config.connector_list);
+	list_add_tail(&connector->head, &config->connector_list);
-	dev->mode_config.num_connector++;
+	config->num_connector++;
 	if (connector_type != DRM_MODE_CONNECTOR_VIRTUAL)
 		drm_object_attach_property(&connector->base,
-					      dev->mode_config.edid_property,
+					      config->edid_property,
 );
+	drm_object_attach_property(&connector->base,
+				      config->dpms_property, 0);
 	if (drm_core_check_feature(dev, DRIVER_ATOMIC)) {
-	drm_object_attach_property(&connector->base,
+		drm_object_attach_property(&connector->base, config->prop_crtc_id, 0);
 				      dev->mode_config.dpms_property, 0);
 void drm_connector_cleanup(struct drm_connector *connector)
+{
 	struct drm_device *dev = connector->dev;
 	struct drm_display_mode *mode, *t;
+	if (connector->tile_group) {
+		drm_mode_put_tile_group(dev, connector->tile_group);
+		connector->tile_group = NULL;
+	}
 	list_for_each_entry_safe(mode, t, &connector->probed_modes, head)
 		drm_mode_remove(connector, mode);
 	list_for_each_entry_safe(mode, t, &connector->modes, head)
 		drm_mode_remove(connector, mode);
 	ida_remove(&drm_connector_enum_list[connector->connector_type].ida,
-	ida_remove(&drm_connector_enum_list[connector->connector_type].ida,
+		   connector->connector_type_id);
 		   connector->connector_type_id);
 	kfree(connector->display_info.bus_formats);
 	drm_mode_object_put(dev, &connector->base);
 	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) {
+	drm_for_each_connector(tmp, connector->dev) {
 		if (tmp == connector)
 			return index;
+{
 	int ret;
+	drm_mode_object_register(connector->dev, &connector->base);
+	ret = drm_sysfs_connector_add(connector);
-	drm_mode_object_register(connector->dev, &connector->base);
+	if (ret)
 		return ret;
 	return 0;
+}
+ *
  * Unregister userspace interfaces for a connector
  */
 void drm_connector_unregister(struct drm_connector *connector)
+{
+	drm_sysfs_connector_remove(connector);
+}
 EXPORT_SYMBOL(drm_connector_unregister);
  */
 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 */
+	/* FIXME: 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
- *
- * Initialises a preallocated bridge. Bridges should be
- * subclassed as part of driver connector objects.
- *
- * Returns:
- * Zero on success, error code on failure.
- */
-int drm_bridge_init(struct drm_device *dev, struct drm_bridge *bridge,
-		const struct drm_bridge_funcs *funcs)
-{
-	int ret;
-	drm_modeset_lock_all(dev);
-	ret = drm_mode_object_get(dev, &bridge->base, DRM_MODE_OBJECT_BRIDGE);
-	if (ret)
-		goto out;
-	bridge->dev = dev;
-	bridge->funcs = funcs;
-	list_add_tail(&bridge->head, &dev->mode_config.bridge_list);
-	dev->mode_config.num_bridge++;
- out:
-	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;
-	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);
+EXPORT_SYMBOL(drm_connector_unplug_all);
 /**
  * drm_encoder_init - Init a preallocated encoder
  * @dev: drm device
  * Cleans up the encoder but doesn't free the object.
  */
 void drm_encoder_cleanup(struct drm_encoder *encoder)
+{
 	struct drm_device *dev = encoder->dev;
 	drm_modeset_lock_all(dev);
 	drm_mode_object_put(dev, &encoder->base);
 	kfree(encoder->name);
 	list_del(&encoder->head);
 	dev->mode_config.num_encoder--;
  * Zero on success, error code on failure.
  */
 int drm_universal_plane_init(struct drm_device *dev, struct drm_plane *plane,
-		   unsigned long possible_crtcs,
+			     unsigned long possible_crtcs,
-		   const struct drm_plane_funcs *funcs,
+			     const struct drm_plane_funcs *funcs,
-		   const uint32_t *formats, uint32_t format_count,
+			     const uint32_t *formats, unsigned int format_count,
 			     enum drm_plane_type type)
+{
+	struct drm_mode_config *config = &dev->mode_config;
 	int ret;
 	ret = drm_mode_object_get(dev, &plane->base, DRM_MODE_OBJECT_PLANE);
 	if (ret)
 	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,
+	plane->format_types = kmalloc_array(format_count, sizeof(uint32_t),
-				      GFP_KERNEL);
+					    GFP_KERNEL);
 	if (!plane->format_types) {
 		DRM_DEBUG_KMS("out of memory when allocating plane\n");
 		drm_mode_object_put(dev, &plane->base);
 	memcpy(plane->format_types, formats, format_count * sizeof(uint32_t));
 	plane->format_count = format_count;
 	plane->possible_crtcs = possible_crtcs;
 	plane->type = type;
-		list_add_tail(&plane->head, &dev->mode_config.plane_list);
+	list_add_tail(&plane->head, &config->plane_list);
-	dev->mode_config.num_total_plane++;
+	config->num_total_plane++;
 	if (plane->type == DRM_PLANE_TYPE_OVERLAY)
-		dev->mode_config.num_overlay_plane++;
+		config->num_overlay_plane++;
 	drm_object_attach_property(&plane->base,
+				   config->plane_type_property,
+				   plane->type);
+	if (drm_core_check_feature(dev, DRIVER_ATOMIC)) {
+		drm_object_attach_property(&plane->base, config->prop_fb_id, 0);
+		drm_object_attach_property(&plane->base, config->prop_crtc_id, 0);
+		drm_object_attach_property(&plane->base, config->prop_crtc_x, 0);
+		drm_object_attach_property(&plane->base, config->prop_crtc_y, 0);
+		drm_object_attach_property(&plane->base, config->prop_crtc_w, 0);
+		drm_object_attach_property(&plane->base, config->prop_crtc_h, 0);
+		drm_object_attach_property(&plane->base, config->prop_src_x, 0);
+		drm_object_attach_property(&plane->base, config->prop_src_y, 0);
+		drm_object_attach_property(&plane->base, config->prop_src_w, 0);
-				   dev->mode_config.plane_type_property,
+		drm_object_attach_property(&plane->base, config->prop_src_h, 0);
 				   plane->type);
 	return 0;
  * 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,
+		   const uint32_t *formats, unsigned int format_count,
 		   bool is_primary)
+{
 	enum drm_plane_type type;
 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) {
+	drm_for_each_plane(tmp, plane->dev) {
 		if (tmp == plane)
 			return index;
 	BUG();
+}
 EXPORT_SYMBOL(drm_plane_index);
+/**
+ * drm_plane_from_index - find the registered plane at an index
+ * @dev: DRM device
+ * @idx: index of registered plane to find for
+ *
+ * Given a plane index, return the registered plane from DRM device's
+ * list of planes with matching index.
+ */
+struct drm_plane *
+drm_plane_from_index(struct drm_device *dev, int idx)
+{
+	struct drm_plane *plane;
+	unsigned int i = 0;
+	drm_for_each_plane(plane, dev) {
+		if (i == idx)
+			return plane;
+		i++;
+	}
+	return NULL;
+}
+EXPORT_SYMBOL(drm_plane_from_index);
 /**
  * drm_plane_force_disable - Forcibly disable a plane
  * @plane: plane to disable
+ *
  * Forces the plane to be disabled.
 		DRM_ERROR("failed to disable plane with busy fb\n");
 		plane->old_fb = NULL;
 		return;
+	}
 	/* disconnect the plane from the fb and crtc: */
-	__drm_framebuffer_unreference(plane->old_fb);
+	drm_framebuffer_unreference(plane->old_fb);
 	plane->old_fb = NULL;
 	plane->fb = NULL;
 	plane->crtc = NULL;
+}
 EXPORT_SYMBOL(drm_plane_force_disable);
-static int drm_mode_create_standard_connector_properties(struct drm_device *dev)
+static int drm_mode_create_standard_properties(struct drm_device *dev)
-{
-	struct drm_property *edid;
+{
-	struct drm_property *dpms;
-	struct drm_property *dev_path;
+	struct drm_property *prop;
 	/*
 	 * Standard properties (apply to all connectors)
 	 */
-	edid = drm_property_create(dev, DRM_MODE_PROP_BLOB |
+	prop = drm_property_create(dev, DRM_MODE_PROP_BLOB |
+				   DRM_MODE_PROP_IMMUTABLE,
+				   "EDID", 0);
-				   DRM_MODE_PROP_IMMUTABLE,
+	if (!prop)
-				   "EDID", 0);
+		return -ENOMEM;
-	dev->mode_config.edid_property = edid;
+	dev->mode_config.edid_property = prop;
+	prop = drm_property_create_enum(dev, 0,
+				   "DPMS", drm_dpms_enum_list,
-	dpms = drm_property_create_enum(dev, 0,
+				   ARRAY_SIZE(drm_dpms_enum_list));
-				   "DPMS", drm_dpms_enum_list,
+	if (!prop)
-				   ARRAY_SIZE(drm_dpms_enum_list));
+		return -ENOMEM;
-	dev->mode_config.dpms_property = dpms;
+	dev->mode_config.dpms_property = prop;
+	prop = drm_property_create(dev,
+				   DRM_MODE_PROP_BLOB |
-	dev_path = drm_property_create(dev,
+				   DRM_MODE_PROP_IMMUTABLE,
-				       DRM_MODE_PROP_BLOB |
+				   "PATH", 0);
-				       DRM_MODE_PROP_IMMUTABLE,
+	if (!prop)
-				       "PATH", 0);
+		return -ENOMEM;
-	dev->mode_config.path_property = dev_path;
+	dev->mode_config.path_property = prop;
+	prop = drm_property_create(dev,
+				   DRM_MODE_PROP_BLOB |
-	dev->mode_config.tile_property = drm_property_create(dev,
-							     DRM_MODE_PROP_BLOB |
-							     DRM_MODE_PROP_IMMUTABLE,
-							     "TILE", 0);
-	return 0;
-}
-static int drm_mode_create_standard_plane_properties(struct drm_device *dev)
-{
+				   DRM_MODE_PROP_IMMUTABLE,
-	struct drm_property *type;
+				   "TILE", 0);
 	if (!prop)
+		return -ENOMEM;
+	dev->mode_config.tile_property = prop;
-	/*
+	prop = drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE,
+					"type", drm_plane_type_enum_list,
+					ARRAY_SIZE(drm_plane_type_enum_list));
+	if (!prop)
+		return -ENOMEM;
+	dev->mode_config.plane_type_property = prop;
+	prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
+			"SRC_X", 0, UINT_MAX);
+	if (!prop)
+		return -ENOMEM;
+	dev->mode_config.prop_src_x = prop;
+	prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
+			"SRC_Y", 0, UINT_MAX);
+	if (!prop)
+		return -ENOMEM;
+	dev->mode_config.prop_src_y = prop;
+	prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
+			"SRC_W", 0, UINT_MAX);
+	if (!prop)
+		return -ENOMEM;
+	dev->mode_config.prop_src_w = prop;
+	prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
+			"SRC_H", 0, UINT_MAX);
+	if (!prop)
+		return -ENOMEM;
+	dev->mode_config.prop_src_h = prop;
+	prop = drm_property_create_signed_range(dev, DRM_MODE_PROP_ATOMIC,
+			"CRTC_X", INT_MIN, INT_MAX);
+	if (!prop)
+		return -ENOMEM;
+	dev->mode_config.prop_crtc_x = prop;
+	prop = drm_property_create_signed_range(dev, DRM_MODE_PROP_ATOMIC,
+			"CRTC_Y", INT_MIN, INT_MAX);
+	if (!prop)
+		return -ENOMEM;
+	dev->mode_config.prop_crtc_y = prop;
+	prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
+			"CRTC_W", 0, INT_MAX);
+	if (!prop)
+		return -ENOMEM;
+	dev->mode_config.prop_crtc_w = prop;
+	prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
+			"CRTC_H", 0, INT_MAX);
+	if (!prop)
+		return -ENOMEM;
+	dev->mode_config.prop_crtc_h = prop;
+	prop = drm_property_create_object(dev, DRM_MODE_PROP_ATOMIC,
+			"FB_ID", DRM_MODE_OBJECT_FB);
+	if (!prop)
+		return -ENOMEM;
+	dev->mode_config.prop_fb_id = prop;
+	prop = drm_property_create_object(dev, DRM_MODE_PROP_ATOMIC,
+			"CRTC_ID", DRM_MODE_OBJECT_CRTC);
+	if (!prop)
+		return -ENOMEM;
+	dev->mode_config.prop_crtc_id = prop;
+	prop = drm_property_create_bool(dev, DRM_MODE_PROP_ATOMIC,
+			"ACTIVE");
+	if (!prop)
+		return -ENOMEM;
+	dev->mode_config.prop_active = prop;
-	 * Standard properties (apply to all planes)
+	prop = drm_property_create(dev,
-	 */
+			DRM_MODE_PROP_ATOMIC | DRM_MODE_PROP_BLOB,
-	type = drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE,
+			"MODE_ID", 0);
  * responsible for allocating a list of format names and passing them to
  * this routine.
  */
 int drm_mode_create_tv_properties(struct drm_device *dev,
 				  unsigned int num_modes,
-				  char *modes[])
+				  const char * const modes[])
+{
 	struct drm_property *tv_selector;
 	struct drm_property *tv_subconnector;
 	unsigned int i;
 	 */
 	tv_selector = drm_property_create_enum(dev, 0,
 					  "select subconnector",
 					  drm_tv_select_enum_list,
 					  ARRAY_SIZE(drm_tv_select_enum_list));
+	if (!tv_selector)
+		goto nomem;
 	dev->mode_config.tv_select_subconnector_property = tv_selector;
 	tv_subconnector =
 		drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE,
 				    "subconnector",
 				    drm_tv_subconnector_enum_list,
+				    ARRAY_SIZE(drm_tv_subconnector_enum_list));
+	if (!tv_subconnector)
-				    ARRAY_SIZE(drm_tv_subconnector_enum_list));
+		goto nomem;
 	dev->mode_config.tv_subconnector_property = tv_subconnector;
 	/*
 	 * Other, TV specific properties: margins & TV modes.
 	 */
+	dev->mode_config.tv_left_margin_property =
+		drm_property_create_range(dev, 0, "left margin", 0, 100);
-	dev->mode_config.tv_left_margin_property =
+	if (!dev->mode_config.tv_left_margin_property)
-		drm_property_create_range(dev, 0, "left margin", 0, 100);
+		goto nomem;
+	dev->mode_config.tv_right_margin_property =
 		drm_property_create_range(dev, 0, "right margin", 0, 100);
-	dev->mode_config.tv_right_margin_property =
+	if (!dev->mode_config.tv_right_margin_property)
+		goto nomem;
-		drm_property_create_range(dev, 0, "right margin", 0, 100);
+	dev->mode_config.tv_top_margin_property =
 		drm_property_create_range(dev, 0, "top margin", 0, 100);
+	if (!dev->mode_config.tv_top_margin_property)
+		goto nomem;
 	dev->mode_config.tv_top_margin_property =
-		drm_property_create_range(dev, 0, "top margin", 0, 100);
+	dev->mode_config.tv_bottom_margin_property =
 		drm_property_create_range(dev, 0, "bottom margin", 0, 100);
+	if (!dev->mode_config.tv_bottom_margin_property)
+		goto nomem;
-	dev->mode_config.tv_bottom_margin_property =
+	dev->mode_config.tv_mode_property =
-		drm_property_create_range(dev, 0, "bottom margin", 0, 100);
+		drm_property_create(dev, DRM_MODE_PROP_ENUM,
 				    "mode", num_modes);
-	dev->mode_config.tv_mode_property =
+	if (!dev->mode_config.tv_mode_property)
-		drm_property_create(dev, DRM_MODE_PROP_ENUM,
+		goto nomem;
+	for (i = 0; i < num_modes; i++)
-				    "mode", num_modes);
+		drm_property_add_enum(dev->mode_config.tv_mode_property, i,
-	for (i = 0; i < num_modes; i++)
+				      i, modes[i]);
+	dev->mode_config.tv_brightness_property =
-		drm_property_add_enum(dev->mode_config.tv_mode_property, i,
+		drm_property_create_range(dev, 0, "brightness", 0, 100);
-				      i, modes[i]);
+	if (!dev->mode_config.tv_brightness_property)
+		goto nomem;
 	dev->mode_config.tv_contrast_property =
-	dev->mode_config.tv_brightness_property =
+		drm_property_create_range(dev, 0, "contrast", 0, 100);
+	if (!dev->mode_config.tv_contrast_property)
+		goto nomem;
 		drm_property_create_range(dev, 0, "brightness", 0, 100);
 	dev->mode_config.tv_flicker_reduction_property =
+		drm_property_create_range(dev, 0, "flicker reduction", 0, 100);
+	if (!dev->mode_config.tv_flicker_reduction_property)
-	dev->mode_config.tv_contrast_property =
+		goto nomem;
 		drm_property_create_range(dev, 0, "contrast", 0, 100);
+	dev->mode_config.tv_overscan_property =
+		drm_property_create_range(dev, 0, "overscan", 0, 100);
 	if (!dev->mode_config.tv_overscan_property)
+		goto nomem;
-	dev->mode_config.tv_flicker_reduction_property =
+	dev->mode_config.tv_saturation_property =
-		drm_property_create_range(dev, 0, "flicker reduction", 0, 100);
+		drm_property_create_range(dev, 0, "saturation", 0, 100);
 	if (!dev->mode_config.tv_saturation_property)
-	dev->mode_config.tv_overscan_property =
+		goto nomem;
 		return -ENOMEM;
 	return 0;
+}
 EXPORT_SYMBOL(drm_mode_create_suggested_offset_properties);
-static int drm_mode_group_init(struct drm_device *dev, struct drm_mode_group *group)
-{
-	uint32_t total_objects = 0;
-	total_objects += dev->mode_config.num_crtc;
-	total_objects += dev->mode_config.num_connector;
-	total_objects += dev->mode_config.num_encoder;
-	total_objects += dev->mode_config.num_bridge;
-	group->id_list = kzalloc(total_objects * sizeof(uint32_t), GFP_KERNEL);
-	if (!group->id_list)
-		return -ENOMEM;
-	group->num_crtcs = 0;
-	group->num_connectors = 0;
-	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;
-	struct drm_encoder *encoder;
-	struct drm_connector *connector;
-	struct drm_bridge *bridge;
-	int ret;
-	if ((ret = drm_mode_group_init(dev, group)))
-		return ret;
-	list_for_each_entry(crtc, &dev->mode_config.crtc_list, head)
-		group->id_list[group->num_crtcs++] = crtc->base.id;
-	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head)
-		group->id_list[group->num_crtcs + group->num_encoders++] =
-		encoder->base.id;
-	list_for_each_entry(connector, &dev->mode_config.connector_list, head)
-		group->id_list[group->num_crtcs + group->num_encoders +
-			       group->num_connectors++] = connector->base.id;
-	list_for_each_entry(bridge, &dev->mode_config.bridge_list, head)
-		group->id_list[group->num_crtcs + group->num_encoders +
-			       group->num_connectors + group->num_bridges++] =
-					bridge->base.id;
-	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_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_display_mode to use
- *
- * Convert a drm_display_mode into a drm_mode_modeinfo structure to return to
- * the user.
- */
-static void drm_crtc_convert_to_umode(struct drm_mode_modeinfo *out,
-				      const struct drm_display_mode *in)
-{
-	WARN(in->hdisplay > USHRT_MAX || in->hsync_start > USHRT_MAX ||
-	     in->hsync_end > USHRT_MAX || in->htotal > USHRT_MAX ||
-	     in->hskew > USHRT_MAX || in->vdisplay > USHRT_MAX ||
-	     in->vsync_start > USHRT_MAX || in->vsync_end > USHRT_MAX ||
-	     in->vtotal > USHRT_MAX || in->vscan > USHRT_MAX,
-	     "timing values too large for mode info\n");
-	out->clock = in->clock;
-	out->hdisplay = in->hdisplay;
-	out->hsync_start = in->hsync_start;
-	out->hsync_end = in->hsync_end;
-	out->htotal = in->htotal;
-	out->hskew = in->hskew;
-	out->vdisplay = in->vdisplay;
-	out->vsync_start = in->vsync_start;
-	out->vsync_end = in->vsync_end;
-	out->vtotal = in->vtotal;
-	out->vscan = in->vscan;
-	out->vrefresh = in->vrefresh;
-	out->flags = in->flags;
-	out->type = in->type;
-	strncpy(out->name, in->name, DRM_DISPLAY_MODE_LEN);
-	out->name[DRM_DISPLAY_MODE_LEN-1] = 0;
-}
-/**
- * drm_crtc_convert_umode - convert a modeinfo into a drm_display_mode
- * @out: drm_display_mode 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:
- * 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)
-		return -ERANGE;
-	if ((in->flags & DRM_MODE_FLAG_3D_MASK) > DRM_MODE_FLAG_3D_MAX)
-		return -EINVAL;
-	out->clock = in->clock;
-	out->hdisplay = in->hdisplay;
-	out->hsync_start = in->hsync_start;
-	out->hsync_end = in->hsync_end;
-	out->htotal = in->htotal;
-	out->hskew = in->hskew;
-	out->vdisplay = in->vdisplay;
-	out->vsync_start = in->vsync_start;
-	out->vsync_end = in->vsync_end;
-	out->vtotal = in->vtotal;
-	out->vscan = in->vscan;
-	out->vrefresh = in->vrefresh;
-	out->flags = in->flags;
-	out->type = in->type;
-	strncpy(out->name, in->name, DRM_DISPLAY_MODE_LEN);
-	out->name[DRM_DISPLAY_MODE_LEN-1] = 0;
-	return 0;
-}
 #if 0
 /**
  * drm_mode_getresources - get graphics configuration
  * @dev: drm device for the ioctl
 	int ret = 0;
 	int connector_count = 0;
 	int crtc_count = 0;
 	int fb_count = 0;
 	int encoder_count = 0;
-	int copied = 0, i;
+	int copied = 0;
 	uint32_t __user *fb_id;
 	uint32_t __user *crtc_id;
 	uint32_t __user *connector_id;
 	uint32_t __user *encoder_id;
-	struct drm_mode_group *mode_group;
 	if (!drm_core_check_feature(dev, DRIVER_MODESET))
 	mutex_unlock(&file_priv->fbs_lock);
 	/* mode_config.mutex protects the connector list against e.g. DP MST
 	 * connector hot-adding. CRTC/Plane lists are invariant. */
-	mutex_lock(&dev->mode_config.mutex);
-	if (!drm_is_primary_client(file_priv)) {
-		mode_group = NULL;
+	mutex_lock(&dev->mode_config.mutex);
-		list_for_each(lh, &dev->mode_config.crtc_list)
+	drm_for_each_crtc(crtc, dev)
-			crtc_count++;
+		crtc_count++;
-		list_for_each(lh, &dev->mode_config.connector_list)
+	drm_for_each_connector(connector, dev)
-			connector_count++;
+		connector_count++;
-		list_for_each(lh, &dev->mode_config.encoder_list)
-			encoder_count++;
-	} else {
-		mode_group = &file_priv->master->minor->mode_group;
-		crtc_count = mode_group->num_crtcs;
 		connector_count = mode_group->num_connectors;
-		encoder_count = mode_group->num_encoders;
+	drm_for_each_encoder(encoder, dev)
 		encoder_count++;
 	card_res->max_height = dev->mode_config.max_height;
 	card_res->min_height = dev->mode_config.min_height;
 	card_res->max_width = dev->mode_config.max_width;
 	card_res->min_width = dev->mode_config.min_width;
-	/* CRTCs */
-	if (card_res->count_crtcs >= crtc_count) {
-		copied = 0;
+	/* CRTCs */
-		crtc_id = (uint32_t __user *)(unsigned long)card_res->crtc_id_ptr;
+	if (card_res->count_crtcs >= crtc_count) {
-		if (!mode_group) {
+		copied = 0;
-			list_for_each_entry(crtc, &dev->mode_config.crtc_list,
+		crtc_id = (uint32_t __user *)(unsigned long)card_res->crtc_id_ptr;
-					    head) {
+		drm_for_each_crtc(crtc, dev) {
-				DRM_DEBUG_KMS("[CRTC:%d]\n", crtc->base.id);
+			DRM_DEBUG_KMS("[CRTC:%d]\n", crtc->base.id);
-				if (put_user(crtc->base.id, crtc_id + copied)) {
+			if (put_user(crtc->base.id, crtc_id + copied)) {
-					ret = -EFAULT;
-					goto out;
-				}
-				copied++;
-			}
-		} else {
-			for (i = 0; i < mode_group->num_crtcs; i++) {
-				if (put_user(mode_group->id_list[i],
-					     crtc_id + copied)) {
-					ret = -EFAULT;
-					goto out;
+				ret = -EFAULT;
 				goto out;
 				copied++;
 			copied++;
+		}
+	}
-	card_res->count_crtcs = crtc_count;
+	card_res->count_crtcs = crtc_count;
-	/* Encoders */
-	if (card_res->count_encoders >= encoder_count) {
 		copied = 0;
-		encoder_id = (uint32_t __user *)(unsigned long)card_res->encoder_id_ptr;
+	/* Encoders */
-		if (!mode_group) {
+	if (card_res->count_encoders >= encoder_count) {
-			list_for_each_entry(encoder,
+		copied = 0;
-					    &dev->mode_config.encoder_list,
+		encoder_id = (uint32_t __user *)(unsigned long)card_res->encoder_id_ptr;
-					    head) {
+		drm_for_each_encoder(encoder, dev) {
-				DRM_DEBUG_KMS("[ENCODER:%d:%s]\n", encoder->base.id,
+			DRM_DEBUG_KMS("[ENCODER:%d:%s]\n", encoder->base.id,
-						encoder->name);
+					encoder->name);
-				if (put_user(encoder->base.id, encoder_id +
+			if (put_user(encoder->base.id, encoder_id +
-					     copied)) {
-					ret = -EFAULT;
-					goto out;
-				}
-				copied++;
-			}
-		} else {
-			for (i = mode_group->num_crtcs; i < mode_group->num_crtcs + mode_group->num_encoders; i++) {
-				if (put_user(mode_group->id_list[i],
-					     encoder_id + copied)) {
-					ret = -EFAULT;
-					goto out;
+				     copied)) {
 				ret = -EFAULT;
-				copied++;
+				goto out;
+			}
 			copied++;
+		}
-	}
-	card_res->count_encoders = encoder_count;
+	}
-	/* Connectors */
-	if (card_res->count_connectors >= connector_count) {
+	card_res->count_encoders = encoder_count;
 		copied = 0;
-		connector_id = (uint32_t __user *)(unsigned long)card_res->connector_id_ptr;
+	/* Connectors */
-		if (!mode_group) {
+	if (card_res->count_connectors >= connector_count) {
-			list_for_each_entry(connector,
+		copied = 0;
-					    &dev->mode_config.connector_list,
+		connector_id = (uint32_t __user *)(unsigned long)card_res->connector_id_ptr;
-					    head) {
+		drm_for_each_connector(connector, dev) {
-				DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n",
+			DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n",
-					connector->base.id,
+				connector->base.id,
-					connector->name);
+				connector->name);
-				if (put_user(connector->base.id,
-					     connector_id + copied)) {
-					ret = -EFAULT;
-					goto out;
-				}
-				copied++;
-			}
-		} else {
-			int start = mode_group->num_crtcs +
-				mode_group->num_encoders;
-			for (i = start; i < start + mode_group->num_connectors; i++) {
-				if (put_user(mode_group->id_list[i],
-					     connector_id + copied)) {
+			if (put_user(connector->base.id,
-					ret = -EFAULT;
+				     connector_id + copied)) {
-					goto out;
+				ret = -EFAULT;
 				goto out;
 	crtc = drm_crtc_find(dev, crtc_resp->crtc_id);
 	if (!crtc)
 		return -ENOENT;
-	drm_modeset_lock_crtc(crtc, crtc->primary);
-	crtc_resp->x = crtc->x;
-	crtc_resp->y = crtc->y;
+	drm_modeset_lock_crtc(crtc, crtc->primary);
 	crtc_resp->gamma_size = crtc->gamma_size;
 	if (crtc->primary->fb)
 		crtc_resp->fb_id = crtc->primary->fb->base.id;
 	else
 		crtc_resp->fb_id = 0;
+	if (crtc->state) {
+		crtc_resp->x = crtc->primary->state->src_x >> 16;
+		crtc_resp->y = crtc->primary->state->src_y >> 16;
+		if (crtc->state->enable) {
+			drm_mode_convert_to_umode(&crtc_resp->mode, &crtc->state->mode);
+			crtc_resp->mode_valid = 1;
+		} else {
+			crtc_resp->mode_valid = 0;
+		}
+	} else {
+		crtc_resp->x = crtc->x;
-	if (crtc->enabled) {
+		crtc_resp->y = crtc->y;
 		if (crtc->enabled) {
-		drm_crtc_convert_to_umode(&crtc_resp->mode, &crtc->mode);
+			drm_mode_convert_to_umode(&crtc_resp->mode, &crtc->mode);
-		crtc_resp->mode_valid = 1;
+			crtc_resp->mode_valid = 1;
 		} else {
-	} else {
+			crtc_resp->mode_valid = 0;
 		crtc_resp->mode_valid = 0;
 	if (connector->state)
 		return connector->state->best_encoder;
 	return connector->encoder;
+}
+/* helper for getconnector and getproperties ioctls */
+static int get_properties(struct drm_mode_object *obj, bool atomic,
+		uint32_t __user *prop_ptr, uint64_t __user *prop_values,
+		uint32_t *arg_count_props)
+{
+	int props_count;
+	int i, ret, copied;
+	props_count = obj->properties->count;
+	if (!atomic)
+		props_count -= obj->properties->atomic_count;
+	if ((*arg_count_props >= props_count) && props_count) {
+		for (i = 0, copied = 0; copied < props_count; i++) {
+			struct drm_property *prop = obj->properties->properties[i];
+			uint64_t val;
+			if ((prop->flags & DRM_MODE_PROP_ATOMIC) && !atomic)
+				continue;
+			ret = drm_object_property_get_value(obj, prop, &val);
+			if (ret)
+				return ret;
+			if (put_user(prop->base.id, prop_ptr + copied))
+				return -EFAULT;
+			if (put_user(val, prop_values + copied))
+				return -EFAULT;
+			copied++;
+		}
+	}
+	*arg_count_props = props_count;
+	return 0;
+}
 /**
  * drm_mode_getconnector - get connector configuration
  * @dev: drm device for the ioctl
  * @data: data pointer for the ioctl
 	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;
 	int copied = 0;
 	int i;
 	struct drm_mode_modeinfo u_mode;
 	struct drm_mode_modeinfo __user *mode_ptr;
-	uint32_t __user *prop_ptr;
-	uint64_t __user *prop_values;
 	uint32_t __user *encoder_ptr;
 	if (!drm_core_check_feature(dev, DRIVER_MODESET))
 	mutex_lock(&dev->mode_config.mutex);
 	connector = drm_connector_find(dev, out_resp->connector_id);
 	if (!connector) {
 		ret = -ENOENT;
-		goto out;
+		goto out_unlock;
-	}
-	props_count = connector->properties.count;
+	}
-	for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
+	for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++)
-		if (connector->encoder_ids[i] != 0) {
-			encoders_count++;
 		if (connector->encoder_ids[i] != 0)
 			encoders_count++;
 	if (out_resp->count_modes == 0) {
 	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);
 	drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
 	encoder = drm_connector_get_encoder(connector);
 	if (encoder)
 		out_resp->encoder_id = encoder->base.id;
 	else
-		out_resp->encoder_id = 0;
-	drm_modeset_unlock(&dev->mode_config.connection_mutex);
+		out_resp->encoder_id = 0;
 	/*
 	 * This ioctl is called twice, once to determine how much space is
 		mode_ptr = (struct drm_mode_modeinfo __user *)(unsigned long)out_resp->modes_ptr;
 		list_for_each_entry(mode, &connector->modes, head) {
 			if (!drm_mode_expose_to_userspace(mode, file_priv))
 				continue;
-			drm_crtc_convert_to_umode(&u_mode, mode);
+			drm_mode_convert_to_umode(&u_mode, mode);
 			if (copy_to_user(mode_ptr + copied,
 					 &u_mode, sizeof(u_mode))) {
 				ret = -EFAULT;
 				goto out;
+			}
 			copied++;
+		}
+	}
 	out_resp->count_modes = mode_count;
-	if ((out_resp->count_props >= props_count) && props_count) {
-		copied = 0;
+	ret = get_properties(&connector->base, file_priv->atomic,
-		prop_ptr = (uint32_t __user *)(unsigned long)(out_resp->props_ptr);
-		prop_values = (uint64_t __user *)(unsigned long)(out_resp->prop_values_ptr);
+			(uint32_t __user *)(unsigned long)(out_resp->props_ptr),
-		for (i = 0; i < connector->properties.count; i++) {
-			if (put_user(connector->properties.ids[i],
-					     prop_ptr + copied)) {
-					ret = -EFAULT;
+			(uint64_t __user *)(unsigned long)(out_resp->prop_values_ptr),
-					goto out;
-				}
-			if (put_user(connector->properties.values[i],
-					     prop_values + copied)) {
+			&out_resp->count_props);
-					ret = -EFAULT;
-					goto out;
-				}
-				copied++;
-			}
 	if (ret)
-	out_resp->count_props = props_count;
+		goto out;
 	if ((out_resp->count_encoders >= encoders_count) && encoders_count) {
+		}
+	}
 	out_resp->count_encoders = encoders_count;
+out:
+	drm_modeset_unlock(&dev->mode_config.connection_mutex);
-out:
+out_unlock:
 	mutex_unlock(&dev->mode_config.mutex);
 	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) {
+	drm_for_each_connector(connector, dev) {
 		if (!connector->state)
 			continue;
 	drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
 	crtc = drm_encoder_get_crtc(encoder);
 	if (crtc)
-		enc_resp->crtc_id = crtc->base.id;
-	else if (encoder->crtc)
-		enc_resp->crtc_id = encoder->crtc->base.id;
+		enc_resp->crtc_id = crtc->base.id;
 	else
 		enc_resp->crtc_id = 0;
 	drm_modeset_unlock(&dev->mode_config.connection_mutex);
 	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) {
+		drm_for_each_plane(plane, dev) {
 			/*
 			 * Unless userspace set the 'universal planes'
 			 * capability bit, only advertise overlays.
 			 */
+	}
 	plane_resp->count_format_types = plane->format_count;
 	return 0;
+}
+#endif
+/**
+ * drm_plane_check_pixel_format - Check if the plane supports the pixel format
+ * @plane: plane to check for format support
+ * @format: the pixel format
+ *
+ * Returns:
+ * Zero of @plane has @format in its list of supported pixel formats, -EINVAL
+ * otherwise.
+ */
+int drm_plane_check_pixel_format(const struct drm_plane *plane, u32 format)
+{
+	unsigned int i;
+	for (i = 0; i < plane->format_count; i++) {
+		if (format == plane->format_types[i])
+			return 0;
+	}
+	return -EINVAL;
+}
+static int check_src_coords(uint32_t src_x, uint32_t src_y,
+			    uint32_t src_w, uint32_t src_h,
+			    const struct drm_framebuffer *fb)
+{
+	unsigned int fb_width, fb_height;
+	fb_width = fb->width << 16;
+	fb_height = fb->height << 16;
+	/* Make sure source coordinates are inside the fb. */
+	if (src_w > fb_width ||
+	    src_x > fb_width - src_w ||
+	    src_h > fb_height ||
+	    src_y > fb_height - src_h) {
+		DRM_DEBUG_KMS("Invalid source coordinates "
+			      "%u.%06ux%u.%06u+%u.%06u+%u.%06u\n",
+			      src_w >> 16, ((src_w & 0xffff) * 15625) >> 10,
+			      src_h >> 16, ((src_h & 0xffff) * 15625) >> 10,
+			      src_x >> 16, ((src_x & 0xffff) * 15625) >> 10,
+			      src_y >> 16, ((src_y & 0xffff) * 15625) >> 10);
+		return -ENOSPC;
+	}
+	return 0;
+}
 /*
  * setplane_internal - setplane handler for internal callers
-			     /* src_{x,y,w,h} values are 16.16 fixed point */
+			       /* src_{x,y,w,h} values are 16.16 fixed point */
-			     uint32_t src_x, uint32_t src_y,
+			       uint32_t src_x, uint32_t src_y,
-			     uint32_t src_w, uint32_t src_h)
+			       uint32_t src_w, uint32_t src_h)
+{
 	int ret = 0;
-	unsigned int fb_width, fb_height;
-	unsigned int i;
 	/* No fb means shut it down */
 	if (!fb) {
 		plane->old_fb = plane->fb;
 		ret = -EINVAL;
 		goto out;
+	}
-	/* Check whether this plane supports the fb pixel format. */
-	for (i = 0; i < plane->format_count; i++)
+	/* Check whether this plane supports the fb pixel format. */
-		if (fb->pixel_format == plane->format_types[i])
+	ret = drm_plane_check_pixel_format(plane, fb->pixel_format);
-			break;
-	if (i == plane->format_count) {
+	if (ret) {
 		DRM_DEBUG_KMS("Invalid pixel format %s\n",
-			      drm_get_format_name(fb->pixel_format));
-		ret = -EINVAL;
+			      drm_get_format_name(fb->pixel_format));
 		goto out;
-	}
-	fb_width = fb->width << 16;
-	fb_height = fb->height << 16;
+	}
-	/* Make sure source coordinates are inside the fb. */
+	/* Give drivers some help against integer overflows */
-	if (src_w > fb_width ||
+	if (crtc_w > INT_MAX ||
-	    src_x > fb_width - src_w ||
+	    crtc_x > INT_MAX - (int32_t) crtc_w ||
-	    src_h > fb_height ||
+	    crtc_h > INT_MAX ||
-	    src_y > fb_height - src_h) {
-		DRM_DEBUG_KMS("Invalid source coordinates "
-			      "%u.%06ux%u.%06u+%u.%06u+%u.%06u\n",
+	    crtc_y > INT_MAX - (int32_t) crtc_h) {
-			      src_w >> 16, ((src_w & 0xffff) * 15625) >> 10,
-			      src_h >> 16, ((src_h & 0xffff) * 15625) >> 10,
-			      src_x >> 16, ((src_x & 0xffff) * 15625) >> 10,
+		DRM_DEBUG_KMS("Invalid CRTC coordinates %ux%u+%d+%d\n",
-			      src_y >> 16, ((src_y & 0xffff) * 15625) >> 10);
+			      crtc_w, crtc_h, crtc_x, crtc_y);
-		ret = -ENOSPC;
+		ret = -ERANGE;
+		goto out;
+	}
+	ret = check_src_coords(src_x, src_y, src_w, src_h, fb);
-		goto out;
+	if (ret)
 		goto out;
 	plane->old_fb = plane->fb;
 	ret = plane->funcs->update_plane(plane, crtc, fb,
 	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;
 		return -EINVAL;
 	/*
 	 * First, find the plane, crtc, and fb objects.  If not available,
 	 * we don't bother to call the driver.
 				 plane_req->crtc_x, plane_req->crtc_y,
 				 plane_req->crtc_w, plane_req->crtc_h,
 				 plane_req->src_x, plane_req->src_y,
 				 plane_req->src_w, plane_req->src_h);
+}
-#endif
 /**
  * drm_mode_set_config_internal - helper to call ->set_config
  * @set: modeset config to set
 	/*
 	 * 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)
+	drm_for_each_crtc(tmp, crtc->dev)
 		tmp->primary->old_fb = tmp->primary->fb;
 	fb = set->fb;
 	ret = crtc->funcs->set_config(set);
 	if (ret == 0) {
 		crtc->primary->crtc = crtc;
 		crtc->primary->fb = fb;
+	}
-	list_for_each_entry(tmp, &crtc->dev->mode_config.crtc_list, head) {
+	drm_for_each_crtc(tmp, crtc->dev) {
 		if (tmp->primary->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);
+/**
+ * drm_crtc_get_hv_timing - Fetches hdisplay/vdisplay for given mode
+ * @mode: mode to query
+ * @hdisplay: hdisplay value to fill in
+ * @vdisplay: vdisplay value to fill in
+ *
+ * The vdisplay value will be doubled if the specified mode is a stereo mode of
+ * the appropriate layout.
+ */
+void drm_crtc_get_hv_timing(const struct drm_display_mode *mode,
+			    int *hdisplay, int *vdisplay)
+{
+	struct drm_display_mode adjusted;
+	drm_mode_copy(&adjusted, mode);
+	drm_mode_set_crtcinfo(&adjusted, CRTC_STEREO_DOUBLE_ONLY);
-	return ret;
+	*hdisplay = adjusted.crtc_hdisplay;
 	*vdisplay = adjusted.crtc_vdisplay;
 EXPORT_SYMBOL(drm_mode_set_config_internal);
 EXPORT_SYMBOL(drm_crtc_get_hv_timing);
 #if 0
-				   const struct drm_framebuffer *fb)
+			    const struct drm_framebuffer *fb)
+{
-	int hdisplay, vdisplay;
-	hdisplay = mode->hdisplay;
-	vdisplay = mode->vdisplay;
+	int hdisplay, vdisplay;
-	if (drm_mode_is_stereo(mode)) {
-		struct drm_display_mode adjusted = *mode;
+	drm_crtc_get_hv_timing(mode, &hdisplay, &vdisplay);
-		drm_mode_set_crtcinfo(&adjusted, CRTC_STEREO_DOUBLE);
-		hdisplay = adjusted.crtc_hdisplay;
-		vdisplay = adjusted.crtc_vdisplay;
 	if (crtc->state &&
-	if (crtc->invert_dimensions)
-		swap(hdisplay, vdisplay);
+	    crtc->primary->state->rotation & (BIT(DRM_ROTATE_90) |
+					      BIT(DRM_ROTATE_270)))
-	if (hdisplay > fb->width ||
-	    vdisplay > fb->height ||
-	    x > fb->width - hdisplay ||
-	    y > fb->height - vdisplay) {
-		DRM_DEBUG_KMS("Invalid fb size %ux%u for CRTC viewport %ux%u+%d+%d%s.\n",
-			      fb->width, fb->height, hdisplay, vdisplay, x, y,
-			      crtc->invert_dimensions ? " (inverted)" : "");
-		return -ENOSPC;
+		swap(hdisplay, vdisplay);
+	return check_src_coords(x << 16, y << 16,
 				hdisplay << 16, vdisplay << 16, fb);
 	return 0;
 EXPORT_SYMBOL(drm_crtc_check_viewport);
 EXPORT_SYMBOL(drm_crtc_check_viewport);
 #if 0
 	int i;
 	if (!drm_core_check_feature(dev, DRIVER_MODESET))
+		return -EINVAL;
-		return -EINVAL;
+	/*
+	 * Universal plane src offsets are only 16.16, prevent havoc for
+	 * drivers using universal plane code internally.
-	/* For some reason crtc x/y offsets are signed internally. */
+	 */
-	if (crtc_req->x > INT_MAX || crtc_req->y > INT_MAX)
+	if (crtc_req->x & 0xffff0000 || crtc_req->y & 0xffff0000)
 		return -ERANGE;
 		if (!mode) {
 			ret = -ENOMEM;
 			goto out;
+		}
-		ret = drm_crtc_convert_umode(mode, &crtc_req->mode);
+		ret = drm_mode_convert_umode(mode, &crtc_req->mode);
 		if (ret) {
 			DRM_DEBUG_KMS("Invalid mode\n");
 			goto out;
+		}
+		drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V);
+		/*
+		 * Check whether the primary plane supports the fb pixel format.
+		 * Drivers not implementing the universal planes API use a
+		 * default formats list provided by the DRM core which doesn't
+		 * match real hardware capabilities. Skip the check in that
+		 * case.
+		 */
+		if (!crtc->primary->format_default) {
+			ret = drm_plane_check_pixel_format(crtc->primary,
+							   fb->pixel_format);
+			if (ret) {
+				DRM_DEBUG_KMS("Invalid pixel format %s\n",
+					drm_get_format_name(fb->pixel_format));
+				goto out;
+			}
 		drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V);
 		ret = drm_crtc_check_viewport(crtc, crtc_req->x, crtc_req->y,
 		if (crtc_req->count_connectors > config->num_connector) {
 			ret = -EINVAL;
 			goto out;
+		}
-		connector_set = kmalloc(crtc_req->count_connectors *
+		connector_set = kmalloc_array(crtc_req->count_connectors,
-					sizeof(struct drm_connector *),
+					      sizeof(struct drm_connector *),
-					GFP_KERNEL);
+					      GFP_KERNEL);
 		if (!connector_set) {
 			ret = -ENOMEM;
 			goto out;
+		}
 		for (i = 0; i < crtc_req->count_connectors; i++) {
 			set_connectors_ptr = (uint32_t __user *)(unsigned long)crtc_req->set_connectors_ptr;
-			if (get_user(out_id, &set_connectors_ptr[i])) {
+//           if (get_user(out_id, &set_connectors_ptr[i])) {
-				ret = -EFAULT;
+//               ret = -EFAULT;
-				goto out;
+//               goto out;
 //           }
 			connector = drm_connector_find(dev, out_id);
  */
 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
 		if (r->pitches[i] < width * cpp) {
 			DRM_DEBUG_KMS("bad pitch %u for plane %d\n", r->pitches[i], i);
 			return -EINVAL;
+		}
+		if (r->modifier[i] && !(r->flags & DRM_MODE_FB_MODIFIERS)) {
+			DRM_DEBUG_KMS("bad fb modifier %llu for plane %d\n",
+				      r->modifier[i], i);
+			return -EINVAL;
+		}
+		/* modifier specific checks: */
+		switch (r->modifier[i]) {
+		case DRM_FORMAT_MOD_SAMSUNG_64_32_TILE:
+			/* NOTE: the pitch restriction may be lifted later if it turns
+			 * out that no hw has this restriction:
+			 */
+			if (r->pixel_format != DRM_FORMAT_NV12 ||
+					width % 128 || height % 32 ||
+					r->pitches[i] % 128) {
+				DRM_DEBUG_KMS("bad modifier data for plane %d\n", i);
+				return -EINVAL;
+			}
+			break;
+		default:
+			break;
+		}
+	}
+	for (i = num_planes; i < 4; i++) {
+		if (r->modifier[i]) {
+			DRM_DEBUG_KMS("non-zero modifier for unused plane %d\n", i);
+			return -EINVAL;
+		}
+		/* Pre-FB_MODIFIERS userspace didn't clear the structs properly. */
+		if (!(r->flags & DRM_MODE_FB_MODIFIERS))
+			continue;
+		if (r->handles[i]) {
+			DRM_DEBUG_KMS("buffer object handle for unused plane %d\n", i);
+			return -EINVAL;
+		}
+		if (r->pitches[i]) {
+			DRM_DEBUG_KMS("non-zero pitch for unused plane %d\n", i);
+			return -EINVAL;
+		}
+		if (r->offsets[i]) {
+			DRM_DEBUG_KMS("non-zero offset for unused plane %d\n", i);
+			return -EINVAL;
+		}
+	}
+	return 0;
-	return 0;
+}
 static struct drm_framebuffer *
-static struct drm_framebuffer *add_framebuffer_internal(struct drm_device *dev,
+internal_framebuffer_create(struct drm_device *dev,
-							struct drm_mode_fb_cmd2 *r,
+			    struct drm_mode_fb_cmd2 *r,
-							struct drm_file *file_priv)
+			    struct drm_file *file_priv)
+{
 	struct drm_mode_config *config = &dev->mode_config;
 	struct drm_framebuffer *fb;
 	int ret;
-	if (r->flags & ~DRM_MODE_FB_INTERLACED) {
+	if (r->flags & ~(DRM_MODE_FB_INTERLACED | DRM_MODE_FB_MODIFIERS)) {
 		DRM_DEBUG_KMS("bad framebuffer height %d, should be >= %d && <= %d\n",
 			  r->height, config->min_height, config->max_height);
 		return ERR_PTR(-EINVAL);
+	}
+	if (r->flags & DRM_MODE_FB_MODIFIERS &&
+	    !dev->mode_config.allow_fb_modifiers) {
+		DRM_DEBUG_KMS("driver does not support fb modifiers\n");
+		return ERR_PTR(-EINVAL);
+	}
 	ret = framebuffer_check(r);
 	if (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 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);
+		return fb;
 	mutex_unlock(&file_priv->fbs_lock);
 	return fb;
  * Zero on success, negative errno on failure.
  */
 int drm_mode_addfb2(struct drm_device *dev,
 		    void *data, struct drm_file *file_priv)
+{
+	struct drm_mode_fb_cmd2 *r = data;
 	struct drm_framebuffer *fb;
 	if (!drm_core_check_feature(dev, DRIVER_MODESET))
 		return -EINVAL;
-	fb = add_framebuffer_internal(dev, data, file_priv);
+	fb = internal_framebuffer_create(dev, r, file_priv);
+	if (IS_ERR(fb))
+		return PTR_ERR(fb);
+	/* Transfer ownership to the filp for reaping on close */
+	DRM_DEBUG_KMS("[FB:%d]\n", fb->base.id);
+	mutex_lock(&file_priv->fbs_lock);
+	r->fb_id = fb->base.id;
-	if (IS_ERR(fb))
+	list_add(&fb->filp_head, &file_priv->fbs);
-		return PTR_ERR(fb);
+	mutex_unlock(&file_priv->fbs_lock);
 	return 0;
 		if (fb == fbl)
 			found = 1;
 	if (!found)
 		goto fail_lookup;
-	/* Mark fb as reaped, we still have a ref from fpriv->fbs. */
-	__drm_framebuffer_unregister(dev, fb);
 	list_del_init(&fb->filp_head);
 	mutex_unlock(&dev->mode_config.fb_lock);
 	mutex_unlock(&file_priv->fbs_lock);
-	drm_framebuffer_remove(fb);
+	drm_framebuffer_unreference(fb);
 	if (num_clips && clips_ptr) {
 		if (num_clips < 0 || num_clips > DRM_MODE_FB_DIRTY_MAX_CLIPS) {
 			ret = -EINVAL;
 			goto out_err1;
+		}
-		clips = kzalloc(num_clips * sizeof(*clips), GFP_KERNEL);
+		clips = kcalloc(num_clips, sizeof(*clips), GFP_KERNEL);
 		if (!clips) {
 			ret = -ENOMEM;
 			goto out_err1;
+		}
  * Returns:
  * 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
 	 * 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.
 	 */
 	list_for_each_entry_safe(fb, tfb, &priv->fbs, filp_head) {
-		mutex_lock(&dev->mode_config.fb_lock);
-		/* Mark fb as reaped, we still have a ref from fpriv->fbs. */
-		__drm_framebuffer_unregister(dev, fb);
-		mutex_unlock(&dev->mode_config.fb_lock);
 		list_del_init(&fb->filp_head);
-		/* This will also drop the fpriv->fbs reference. */
+		/* This drops the fpriv->fbs reference. */
-		drm_framebuffer_remove(fb);
+		drm_framebuffer_unreference(fb);
+	}
+}
 		return NULL;
 	property->dev = dev;
+	if (num_values) {
-	if (num_values) {
+		property->values = kcalloc(num_values, sizeof(uint64_t),
-		property->values = kzalloc(sizeof(uint64_t)*num_values, GFP_KERNEL);
+					   GFP_KERNEL);
 		if (!property->values)
 			goto fail;
 	return property;
+}
 /**
- * drm_property_create_range - create a new ranged property type
+ * drm_property_create_range - create a new unsigned 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 integer value in the (min, max) range
+ * Userspace is allowed to set any unsigned integer value in the (min, max)
- * inclusive.
+ * range inclusive.
+ *
  * Returns:
  * A pointer to the newly created property on success, NULL on failure.
 	return property_create_range(dev, DRM_MODE_PROP_RANGE | flags,
 			name, min, max);
+}
 EXPORT_SYMBOL(drm_property_create_range);
+/**
+ * drm_property_create_signed_range - create a new signed 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 signed integer 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_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);
+/**
+ * drm_property_create_object - create a new object property type
+ * @dev: drm device
+ * @flags: flags specifying the property type
+ * @name: name of the property
+ * @type: object type from DRM_MODE_OBJECT_* defines
+ *
+ * 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 this to any property value of the given
+ * @type. Only useful for atomic properties, which is enforced.
+ *
+ * Returns:
-EXPORT_SYMBOL(drm_property_create_signed_range);
+ * A pointer to the newly created property on success, NULL on failure.
  */
 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;
 	struct drm_property *property;
 	if (WARN_ON(!(flags & DRM_MODE_PROP_ATOMIC)))
-	flags |= DRM_MODE_PROP_OBJECT;
+		return NULL;
 	return property;
+}
 EXPORT_SYMBOL(drm_property_create_object);
+/**
+ * drm_property_create_bool - create a new boolean property type
+ * @dev: drm device
+ * @flags: flags specifying the property type
+ * @name: name 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.
+ *
+ * This is implemented as a ranged property with only {0, 1} as valid values.
+ *
+ * Returns:
+ * A pointer to the newly created property on success, NULL on failure.
+ */
+struct drm_property *drm_property_create_bool(struct drm_device *dev, int flags,
+					 const char *name)
+{
+	return drm_property_create_range(dev, flags, name, 0, 1);
+}
+EXPORT_SYMBOL(drm_property_create_bool);
 /**
  * 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
 			"you see this message on the same object type.\n",
 			obj->type);
 		return;
+	}
-	obj->properties->ids[count] = property->base.id;
+	obj->properties->properties[count] = property;
 	obj->properties->values[count] = init_val;
+	obj->properties->count++;
+	if (property->flags & DRM_MODE_PROP_ATOMIC)
-	obj->properties->count++;
+		obj->properties->atomic_count++;
+}
 EXPORT_SYMBOL(drm_object_attach_property);
 				  struct drm_property *property, uint64_t val)
+{
 	int i;
 	for (i = 0; i < obj->properties->count; i++) {
-		if (obj->properties->ids[i] == property->base.id) {
+		if (obj->properties->properties[i] == property) {
 			obj->properties->values[i] = val;
 			return 0;
+		}
 int drm_object_property_get_value(struct drm_mode_object *obj,
 				  struct drm_property *property, uint64_t *val)
+{
 	int i;
+	/* read-only properties bypass atomic mechanism and still store
+	 * their value in obj->properties->values[].. mostly to avoid
+	 * having to deal w/ EDID and similar props in atomic paths:
+	 */
+	if (drm_core_check_feature(property->dev, DRIVER_ATOMIC) &&
+			!(property->flags & DRM_MODE_PROP_IMMUTABLE))
+		return drm_atomic_get_property(obj, property, val);
 	for (i = 0; i < obj->properties->count; i++) {
-		if (obj->properties->ids[i] == property->base.id) {
+		if (obj->properties->properties[i] == property) {
 			*val = obj->properties->values[i];
 			return 0;
+		}
 	drm_modeset_unlock_all(dev);
 	return ret;
+}
 #endif
+/**
+ * drm_property_create_blob - Create new blob property
+ *
+ * Creates a new blob property for a specified DRM device, optionally
+ * copying data.
+ *
+ * @dev: DRM device to create property for
+ * @length: Length to allocate for blob data
+ * @data: If specified, copies data into blob
+ *
+ * Returns:
+ * New blob property with a single reference on success, or an ERR_PTR
+ * value on failure.
+ */
-static struct drm_property_blob *
+struct drm_property_blob *
 drm_property_create_blob(struct drm_device *dev, size_t length,
 			 const void *data)
+{
 	struct drm_property_blob *blob;
 	int ret;
-	if (!length || !data)
+	if (!length || length > ULONG_MAX - sizeof(struct drm_property_blob))
-		return NULL;
+		return ERR_PTR(-EINVAL);
+	blob = kzalloc(sizeof(struct drm_property_blob)+length, GFP_KERNEL);
+	if (!blob)
+		return ERR_PTR(-ENOMEM);
+	/* This must be explicitly initialised, so we can safely call list_del
+	 * on it in the removal handler, even if it isn't in a file list. */
+	INIT_LIST_HEAD(&blob->head_file);
+	blob->length = length;
+	blob->dev = dev;
+	if (data)
-	blob = kzalloc(sizeof(struct drm_property_blob)+length, GFP_KERNEL);
+		memcpy(blob->data, data, length);
 	if (!blob)
-		return NULL;
+	mutex_lock(&dev->mode_config.blob_lock);
+	ret = drm_mode_object_get(dev, &blob->base, DRM_MODE_OBJECT_BLOB);
-	ret = drm_mode_object_get(dev, &blob->base, DRM_MODE_OBJECT_BLOB);
+	if (ret) {
-	if (ret) {
+		kfree(blob);
+		mutex_unlock(&dev->mode_config.blob_lock);
+		return ERR_PTR(-EINVAL);
+	}
-		kfree(blob);
-		return NULL;
 	kref_init(&blob->refcount);
+	list_add_tail(&blob->head_global,
+	              &dev->mode_config.property_blob_list);
-	blob->length = length;
+	mutex_unlock(&dev->mode_config.blob_lock);
+	return blob;
+}
+EXPORT_SYMBOL(drm_property_create_blob);
-	memcpy(blob->data, data, length);
+/**
+ * drm_property_free_blob - Blob property destructor
+ *
+ * Internal free function for blob properties; must not be used directly.
+ *
+ * @kref: Reference
+ */
-	list_add_tail(&blob->head, &dev->mode_config.property_blob_list);
+static void drm_property_free_blob(struct kref *kref)
+{
+	struct drm_property_blob *blob =
-	return blob;
+		container_of(kref, struct drm_property_blob, refcount);
+	WARN_ON(!mutex_is_locked(&blob->dev->mode_config.blob_lock));
+	list_del(&blob->head_global);
+	list_del(&blob->head_file);
+	drm_mode_object_put(blob->dev, &blob->base);
+	kfree(blob);
+}
+/**
+ * drm_property_unreference_blob - Unreference a blob property
+ *
+ * Drop a reference on a blob property. May free the object.
+ *
+ * @blob: Pointer to blob property
+ */
+void drm_property_unreference_blob(struct drm_property_blob *blob)
+{
+	struct drm_device *dev;
+	if (!blob)
+		return;
+	dev = blob->dev;
+	DRM_DEBUG("%p: blob ID: %d (%d)\n", blob, blob->base.id, atomic_read(&blob->refcount.refcount));
+	if (kref_put_mutex(&blob->refcount, drm_property_free_blob,
+			   &dev->mode_config.blob_lock))
+		mutex_unlock(&dev->mode_config.blob_lock);
+	else
+		might_lock(&dev->mode_config.blob_lock);
+}
+EXPORT_SYMBOL(drm_property_unreference_blob);
+/**
+ * drm_property_unreference_blob_locked - Unreference a blob property with blob_lock held
+ *
+ * Drop a reference on a blob property. May free the object. This must be
+ * called with blob_lock held.
+ *
+ * @blob: Pointer to blob property
+ */
+static void drm_property_unreference_blob_locked(struct drm_property_blob *blob)
+{
+	if (!blob)
+		return;
+	DRM_DEBUG("%p: blob ID: %d (%d)\n", blob, blob->base.id, atomic_read(&blob->refcount.refcount));
+	kref_put(&blob->refcount, drm_property_free_blob);
+}
+/**
+ * drm_property_destroy_user_blobs - destroy all blobs created by this client
+ * @dev:       DRM device
+ * @file_priv: destroy all blobs owned by this file handle
+ */
+void drm_property_destroy_user_blobs(struct drm_device *dev,
+				     struct drm_file *file_priv)
+{
+	struct drm_property_blob *blob, *bt;
+	mutex_lock(&dev->mode_config.blob_lock);
+	list_for_each_entry_safe(blob, bt, &file_priv->blobs, head_file) {
+		list_del_init(&blob->head_file);
+		drm_property_unreference_blob_locked(blob);
+	}
+	mutex_unlock(&dev->mode_config.blob_lock);
+}
+/**
+ * drm_property_reference_blob - Take a reference on an existing property
+ *
+ * Take a new reference on an existing blob property.
+ *
+ * @blob: Pointer to blob property
+ */
+struct drm_property_blob *drm_property_reference_blob(struct drm_property_blob *blob)
+{
+	DRM_DEBUG("%p: blob ID: %d (%d)\n", blob, blob->base.id, atomic_read(&blob->refcount.refcount));
+	kref_get(&blob->refcount);
+	return blob;
+}
+EXPORT_SYMBOL(drm_property_reference_blob);
+/*
+ * Like drm_property_lookup_blob, but does not return an additional reference.
+ * Must be called with blob_lock held.
+ */
+static struct drm_property_blob *__drm_property_lookup_blob(struct drm_device *dev,
+							    uint32_t id)
+{
+	struct drm_mode_object *obj = NULL;
+	struct drm_property_blob *blob;
+	WARN_ON(!mutex_is_locked(&dev->mode_config.blob_lock));
+	mutex_lock(&dev->mode_config.idr_mutex);
+	obj = idr_find(&dev->mode_config.crtc_idr, id);
+	if (!obj || (obj->type != DRM_MODE_OBJECT_BLOB) || (obj->id != id))
+		blob = NULL;
+	else
+		blob = obj_to_blob(obj);
+	mutex_unlock(&dev->mode_config.idr_mutex);
+	return blob;
+}
+/**
+ * drm_property_lookup_blob - look up a blob property and take a reference
+ * @dev: drm device
+ * @id: id of the blob property
+ *
+ * If successful, this takes an additional reference to the blob property.
+ * callers need to make sure to eventually unreference the returned property
+ * again, using @drm_property_unreference_blob.
+ */
+struct drm_property_blob *drm_property_lookup_blob(struct drm_device *dev,
+					           uint32_t id)
+{
+	struct drm_property_blob *blob;
+	mutex_lock(&dev->mode_config.blob_lock);
+	blob = __drm_property_lookup_blob(dev, id);
+	if (blob) {
+		if (!kref_get_unless_zero(&blob->refcount))
+			blob = NULL;
+	}
+	mutex_unlock(&dev->mode_config.blob_lock);
+	return blob;
+}
+EXPORT_SYMBOL(drm_property_lookup_blob);
+/**
+ * drm_property_replace_global_blob - atomically replace existing blob property
+ * @dev: drm device
+ * @replace: location of blob property pointer to be replaced
+ * @length: length of data for new blob, or 0 for no data
+ * @data: content for new blob, or NULL for no data
+ * @obj_holds_id: optional object for property holding blob ID
+ * @prop_holds_id: optional property holding blob ID
+ * @return 0 on success or error on failure
+ *
+ * This function will atomically replace a global property in the blob list,
+ * optionally updating a property which holds the ID of that property. It is
+ * guaranteed to be atomic: no caller will be allowed to see intermediate
+ * results, and either the entire operation will succeed and clean up the
+ * previous property, or it will fail and the state will be unchanged.
+ *
+ * If length is 0 or data is NULL, no new blob will be created, and the holding
+ * property, if specified, will be set to 0.
+ *
+ * Access to the replace pointer is assumed to be protected by the caller, e.g.
+ * by holding the relevant modesetting object lock for its parent.
+ *
+ * For example, a drm_connector has a 'PATH' property, which contains the ID
+ * of a blob property with the value of the MST path information. Calling this
+ * function with replace pointing to the connector's path_blob_ptr, length and
+ * data set for the new path information, obj_holds_id set to the connector's
+ * base object, and prop_holds_id set to the path property name, will perform
+ * a completely atomic update. The access to path_blob_ptr is protected by the
+ * caller holding a lock on the connector.
+ */
+static int drm_property_replace_global_blob(struct drm_device *dev,
+                                            struct drm_property_blob **replace,
+                                            size_t length,
+                                            const void *data,
+                                            struct drm_mode_object *obj_holds_id,
+                                            struct drm_property *prop_holds_id)
+{
+	struct drm_property_blob *new_blob = NULL;
+	struct drm_property_blob *old_blob = NULL;
+	int ret;
+	WARN_ON(replace == NULL);
+	old_blob = *replace;
+	if (length && data) {
+		new_blob = drm_property_create_blob(dev, length, data);
+		if (IS_ERR(new_blob))
+			return PTR_ERR(new_blob);
+	}
+	/* This does not need to be synchronised with blob_lock, as the
+	 * get_properties ioctl locks all modesetting objects, and
+	 * obj_holds_id must be locked before calling here, so we cannot
+	 * have its value out of sync with the list membership modified
+	 * below under blob_lock. */
+	if (obj_holds_id) {
+		ret = drm_object_property_set_value(obj_holds_id,
+						    prop_holds_id,
+						    new_blob ?
+						        new_blob->base.id : 0);
+		if (ret != 0)
+			goto err_created;
+	}
+	drm_property_unreference_blob(old_blob);
+	*replace = new_blob;
-static void drm_property_destroy_blob(struct drm_device *dev,
+	return 0;
 			       struct drm_property_blob *blob)
 err_created:
-	drm_mode_object_put(dev, &blob->base);
+	drm_property_unreference_blob(new_blob);
 	if (!drm_core_check_feature(dev, DRIVER_MODESET))
 		return -EINVAL;
+	drm_modeset_lock_all(dev);
-	drm_modeset_lock_all(dev);
+	mutex_lock(&dev->mode_config.blob_lock);
-	blob = drm_property_blob_find(dev, out_resp->blob_id);
+	blob = __drm_property_lookup_blob(dev, out_resp->blob_id);
 	if (!blob) {
 		ret = -ENOENT;
+		}
+	}
 	out_resp->length = blob->length;
+done:
-done:
+	mutex_unlock(&dev->mode_config.blob_lock);
 	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.
+ * @path: path to use for property; must not be NULL.
+ *
  * This creates a property to expose to userspace to specify a
  * connector path. This is mainly used for DisplayPort MST where
  */
 int drm_mode_connector_set_path_property(struct drm_connector *connector,
 					 const char *path)
+{
 	struct drm_device *dev = connector->dev;
-	size_t size = strlen(path) + 1;
 	int ret;
-	connector->path_blob_ptr = drm_property_create_blob(connector->dev,
+	ret = drm_property_replace_global_blob(dev,
-							    size, path);
+	                                       &connector->path_blob_ptr,
-	if (!connector->path_blob_ptr)
+	                                       strlen(path) + 1,
-		return -EINVAL;
+	                                       path,
-	ret = drm_object_property_set_value(&connector->base,
+	                                       &connector->base,
-					    dev->mode_config.path_property,
-					    connector->path_blob_ptr->base.id);
+	                                       dev->mode_config.path_property);
 	return ret;
+}
 EXPORT_SYMBOL(drm_mode_connector_set_path_property);
  * 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)
+	int ret;
-		drm_property_destroy_blob(dev, connector->tile_blob_ptr);
 	if (!connector->has_tile) {
+		ret  = drm_property_replace_global_blob(dev,
+		                                        &connector->tile_blob_ptr,
+,
-		connector->tile_blob_ptr = NULL;
+		                                        NULL,
-		ret = drm_object_property_set_value(&connector->base,
+		                                        &connector->base,
-						    dev->mode_config.tile_property, 0);
+		                                        dev->mode_config.tile_property);
 		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);
+		 connector->tile_h_loc, connector->tile_v_loc,
-	size = strlen(tile) + 1;
+		 connector->tile_h_size, connector->tile_v_size);
-	connector->tile_blob_ptr = drm_property_create_blob(connector->dev,
+	ret = drm_property_replace_global_blob(dev,
-							    size, tile);
-	if (!connector->tile_blob_ptr)
+	                                       &connector->tile_blob_ptr,
-		return -EINVAL;
+	                                       strlen(tile) + 1,
-	ret = drm_object_property_set_value(&connector->base,
+	                                       tile,
-					    dev->mode_config.tile_property,
+	                                       &connector->base,
-					    connector->tile_blob_ptr->base.id);
+	                                       dev->mode_config.tile_property);
 	return ret;
  */
 int drm_mode_connector_update_edid_property(struct drm_connector *connector,
 					    const struct edid *edid)
+{
 	struct drm_device *dev = connector->dev;
-	size_t size;
+	size_t size = 0;
 	int ret;
 	/* ignore requests to set edid when overridden */
 	if (connector->override_edid)
 		return 0;
-	if (connector->edid_blob_ptr)
+	if (edid)
-		drm_property_destroy_blob(dev, connector->edid_blob_ptr);
+		size = EDID_LENGTH * (1 + edid->extensions);
+	ret = drm_property_replace_global_blob(dev,
+					       &connector->edid_blob_ptr,
-	/* Delete edid, when there is none. */
+	                                       size,
-	if (!edid) {
+	                                       edid,
-		connector->edid_blob_ptr = NULL;
+	                                       &connector->base,
+	                                       dev->mode_config.edid_property);
-		ret = drm_object_property_set_value(&connector->base, dev->mode_config.edid_property, 0);
+	return ret;
+}
+EXPORT_SYMBOL(drm_mode_connector_update_edid_property);
+/* Some properties could refer to dynamic refcnt'd objects, or things that
-		return ret;
+ * need special locking to handle lifetime issues (ie. to ensure the prop
-	}
+ * value doesn't become invalid part way through the property update due to
+ * race).  The value returned by reference via 'obj' should be passed back
+ * to drm_property_change_valid_put() after the property is set (and the
+ * object to which the property is attached has a chance to take it's own
+ * reference).
+ */
+bool drm_property_change_valid_get(struct drm_property *property,
+					 uint64_t value, struct drm_mode_object **ref)
-	size = EDID_LENGTH * (1 + edid->extensions);
+{
-	connector->edid_blob_ptr = drm_property_create_blob(connector->dev,
-							    size, edid);
+	int i;
-	if (!connector->edid_blob_ptr)
+	if (property->flags & DRM_MODE_PROP_IMMUTABLE)
+		return false;
-		return -EINVAL;
+	*ref = NULL;
+	if (drm_property_type_is(property, DRM_MODE_PROP_RANGE)) {
+		if (value < property->values[0] || value > property->values[1])
+			return false;
+		return true;
+	} else if (drm_property_type_is(property, DRM_MODE_PROP_SIGNED_RANGE)) {
+		int64_t svalue = U642I64(value);
+		if (svalue < U642I64(property->values[0]) ||
+				svalue > U642I64(property->values[1]))
+			return false;
+		return true;
+	} else if (drm_property_type_is(property, DRM_MODE_PROP_BITMASK)) {
+		uint64_t valid_mask = 0;
+		for (i = 0; i < property->num_values; i++)
+			valid_mask |= (1ULL << property->values[i]);
+		return !(value & ~valid_mask);
+	} else if (drm_property_type_is(property, DRM_MODE_PROP_BLOB)) {
+		struct drm_property_blob *blob;
+		if (value == 0)
+			return true;
+		blob = drm_property_lookup_blob(property->dev, value);
+		if (blob) {
+			*ref = &blob->base;
+			return true;
+		} else {
+			return false;
+		}
+	} else if (drm_property_type_is(property, DRM_MODE_PROP_OBJECT)) {
+		/* a zero value for an object property translates to null: */
+		if (value == 0)
+			return true;
+		/* handle refcnt'd objects specially: */
+		if (property->values[0] == DRM_MODE_OBJECT_FB) {
+			struct drm_framebuffer *fb;
+			fb = drm_framebuffer_lookup(property->dev, value);
+			if (fb) {
+				*ref = &fb->base;
+				return true;
+			} else {
+				return false;
+			}
+		} else {
+			return _object_find(property->dev, value, property->values[0]) != NULL;
+		}
+	}
+	for (i = 0; i < property->num_values; i++)
+		if (property->values[i] == value)
+			return true;
+	return false;
+}
+void drm_property_change_valid_put(struct drm_property *property,
+		struct drm_mode_object *ref)
+{
+	if (!ref)
+		return;
-	ret = drm_object_property_set_value(&connector->base,
-					       dev->mode_config.edid_property,
+	if (drm_property_type_is(property, DRM_MODE_PROP_OBJECT)) {
-					       connector->edid_blob_ptr->base.id);
+		if (property->values[0] == DRM_MODE_OBJECT_FB)
 	int ret = -EINVAL;
 	struct drm_connector *connector = obj_to_connector(obj);
 	/* Do DPMS ourselves */
-	if (property == connector->dev->mode_config.dpms_property) {
-		if (connector->funcs->dpms)
-			(*connector->funcs->dpms)(connector, (int)value);
+	if (property == connector->dev->mode_config.dpms_property) {
+		ret = 0;
+		if (connector->funcs->dpms)
-		ret = 0;
+			ret = (*connector->funcs->dpms)(connector, (int)value);
 	} else if (connector->funcs->set_property)
 		ret = connector->funcs->set_property(connector, property, value);
 				      struct drm_file *file_priv)
+{
 	struct drm_mode_obj_get_properties *arg = data;
 	struct drm_mode_object *obj;
 	int ret = 0;
-	int i;
-	int copied = 0;
-	int props_count = 0;
-	uint32_t __user *props_ptr;
-	uint64_t __user *prop_values_ptr;
 	if (!drm_core_check_feature(dev, DRIVER_MODESET))
 		return -EINVAL;
 	if (!obj->properties) {
 		ret = -EINVAL;
 		goto out;
+	}
+	ret = get_properties(obj, file_priv->atomic,
+			(uint32_t __user *)(unsigned long)(arg->props_ptr),
+			(uint64_t __user *)(unsigned long)(arg->prop_values_ptr),
-	props_count = obj->properties->count;
-	/* This ioctl is called twice, once to determine how much space is
-	 * needed, and the 2nd time to fill it. */
-	if ((arg->count_props >= props_count) && props_count) {
-		copied = 0;
-		props_ptr = (uint32_t __user *)(unsigned long)(arg->props_ptr);
-		prop_values_ptr = (uint64_t __user *)(unsigned long)
-				  (arg->prop_values_ptr);
-		for (i = 0; i < props_count; i++) {
-			if (put_user(obj->properties->ids[i],
-				     props_ptr + copied)) {
-				ret = -EFAULT;
-				goto out;
-	}
-			if (put_user(obj->properties->values[i],
-				     prop_values_ptr + copied)) {
-				ret = -EFAULT;
-		goto out;
-	}
-			copied++;
-		}
 			&arg->count_props);
 	arg->count_props = props_count;
 out:
 	drm_modeset_unlock_all(dev);
+{
 	struct drm_mode_obj_set_property *arg = data;
 	struct drm_mode_object *arg_obj;
 	struct drm_mode_object *prop_obj;
 	struct drm_property *property;
-	int ret = -EINVAL;
+	int i, ret = -EINVAL;
-	int i;
+	struct drm_mode_object *ref;
 	if (!drm_core_check_feature(dev, DRIVER_MODESET))
 		return -EINVAL;
+	}
 	if (!arg_obj->properties)
 		goto out;
 	for (i = 0; i < arg_obj->properties->count; i++)
-		if (arg_obj->properties->ids[i] == arg->prop_id)
+		if (arg_obj->properties->properties[i]->base.id == arg->prop_id)
 			break;
 		ret = -ENOENT;
-			goto out;
+		goto out;
+	}
 	property = obj_to_property(prop_obj);
-	if (!drm_property_change_is_valid(property, arg->value))
+	if (!drm_property_change_valid_get(property, arg->value, &ref))
-			goto out;
+		goto out;
 	switch (arg_obj->type) {
 		ret = drm_mode_plane_set_obj_prop(obj_to_plane(arg_obj),
 						  property, arg->value);
-				break;
+		break;
+	}
+	drm_property_change_valid_put(property, ref);
 out:
 	drm_modeset_unlock_all(dev);
 	return ret;
+}
 int drm_mode_crtc_set_gamma_size(struct drm_crtc *crtc,
-				  int gamma_size)
+				 int gamma_size)
+{
 	crtc->gamma_size = gamma_size;
+	crtc->gamma_store = kcalloc(gamma_size, sizeof(uint16_t) * 3,
-	crtc->gamma_store = kzalloc(gamma_size * sizeof(uint16_t) * 3, GFP_KERNEL);
+				    GFP_KERNEL);
 	if (!crtc->gamma_store) {
 		crtc->gamma_size = 0;
 		return -ENOMEM;
 	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)
+	drm_for_each_plane(plane, dev)
 		if (plane->funcs->reset)
 			plane->funcs->reset(plane);
-	list_for_each_entry(crtc, &dev->mode_config.crtc_list, head)
+	drm_for_each_crtc(crtc, dev)
 		if (crtc->funcs->reset)
 			crtc->funcs->reset(crtc);
-	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head)
+	drm_for_each_encoder(encoder, dev)
 		if (encoder->funcs->reset)
-			encoder->funcs->reset(encoder);
 			encoder->funcs->reset(encoder);
 	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
-		connector->status = connector_status_unknown;
+	mutex_lock(&dev->mode_config.mutex);
 	drm_for_each_connector(connector, dev)
 		if (connector->funcs->reset)
 			connector->funcs->reset(connector);
 	mutex_unlock(&dev->mode_config.mutex);
+}
 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 & DRM_REFLECT_MASK) |
-		rotation = (rotation & ~0xf) | BIT((ffs(rotation & 0xf) + 1) % 4);
+		           BIT((ffs(rotation & DRM_ROTATE_MASK) + 1) % 4);
+	}
 	return rotation;
+}
+{
 	mutex_init(&dev->mode_config.mutex);
 	drm_modeset_lock_init(&dev->mode_config.connection_mutex);
 	mutex_init(&dev->mode_config.idr_mutex);
 	mutex_init(&dev->mode_config.fb_lock);
+	mutex_init(&dev->mode_config.blob_lock);
 	INIT_LIST_HEAD(&dev->mode_config.fb_list);
 	INIT_LIST_HEAD(&dev->mode_config.crtc_list);
 	INIT_LIST_HEAD(&dev->mode_config.connector_list);
-	INIT_LIST_HEAD(&dev->mode_config.bridge_list);
 	INIT_LIST_HEAD(&dev->mode_config.encoder_list);
 	INIT_LIST_HEAD(&dev->mode_config.property_list);
 	INIT_LIST_HEAD(&dev->mode_config.property_blob_list);
 	INIT_LIST_HEAD(&dev->mode_config.plane_list);
 	idr_init(&dev->mode_config.crtc_idr);
 	idr_init(&dev->mode_config.tile_idr);
-	drm_modeset_lock_all(dev);
-	drm_mode_create_standard_connector_properties(dev);
+	drm_modeset_lock_all(dev);
-	drm_mode_create_standard_plane_properties(dev);
+	drm_mode_create_standard_properties(dev);
 	drm_modeset_unlock_all(dev);
 	/* Just to be sure */
 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) {
 				 head) {
 		drm_property_destroy(dev, property);
+	}
 	list_for_each_entry_safe(blob, bt, &dev->mode_config.property_blob_list,
-				 head) {
+				 head_global) {
-		drm_property_destroy_blob(dev, blob);
+		drm_property_unreference_blob(blob);
+	}
 	/*
 	 * 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);
+		drm_framebuffer_free(&fb->refcount);
+	}
 	list_for_each_entry_safe(plane, plt, &dev->mode_config.plane_list,
 				 head) {
 	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))
+			if (!kref_get_unless_zero(&tg->refcount))
-//				tg = NULL;
+				tg = NULL;
 			mutex_unlock(&dev->mode_config.idr_mutex);
 			return tg;
+		}
+	}
 	mutex_unlock(&dev->mode_config.idr_mutex);
 	return NULL;
+}
+EXPORT_SYMBOL(drm_mode_get_tile_group);
 /**
  * drm_mode_create_tile_group - create a tile group from a displayid description
  * @dev: DRM device
+	}
 	mutex_unlock(&dev->mode_config.idr_mutex);
 	return tg;
+}

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/drm_crtc.c – Rev 5367 → 6084