 @@ -1,1833 +1,1834 @@
-/*	$NetBSD: drm_crtc.c,v 1.16 2020/02/14 14:34:57 maya Exp $	*/
+/*	$NetBSD: drm_crtc.c,v 1.17 2020/06/27 13:39:05 jmcneill Exp $	*/
 /*
  * Copyright (c) 2006-2008 Intel Corporation
  * Copyright (c) 2007 Dave Airlie <airlied@linux.ie>
  * Copyright (c) 2008 Red Hat Inc.
+ *
  * DRM core CRTC related functions
+ *
  * Permission to use, copy, modify, distribute, and sell this software and its
  * documentation for any purpose is hereby granted without fee, provided that
  * the above copyright notice appear in all copies and that both that copyright
  * notice and this permission notice appear in supporting documentation, and
  * that the name of the copyright holders not be used in advertising or
  * publicity pertaining to distribution of the software without specific,
  * written prior permission.  The copyright holders make no representations
  * about the suitability of this software for any purpose.  It is provided "as
  * is" without express or implied warranty.
+ *
  * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
  * OF THIS SOFTWARE.
+ *
  * Authors:
  *      Keith Packard
  *	Eric Anholt <eric@anholt.net>
  *      Dave Airlie <airlied@linux.ie>
  *      Jesse Barnes <jesse.barnes@intel.com>
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: drm_crtc.c,v 1.16 2020/02/14 14:34:57 maya Exp $");
+__KERNEL_RCSID(0, "$NetBSD: drm_crtc.c,v 1.17 2020/06/27 13:39:05 jmcneill Exp $");
 #include <linux/ctype.h>
 #include <linux/list.h>
 #include <linux/slab.h>
 #include <linux/export.h>
 #include <drm/drmP.h>
 #include <drm/drm_crtc.h>
 #include <drm/drm_edid.h>
 #include <drm/drm_fourcc.h>
 #include <drm/drm_modeset_lock.h>
 #include <drm/drm_atomic.h>
 #include "drm_crtc_internal.h"
 #include "drm_internal.h"
 #include <linux/nbsd-namespace.h>
 static struct drm_framebuffer *
 internal_framebuffer_create(struct drm_device *dev,
 			    struct drm_mode_fb_cmd2 *r,
 			    struct drm_file *file_priv);
 /* Avoid boilerplate.  I'm tired of typing. */
 #define DRM_ENUM_NAME_FN(fnname, list)				\
 	const char *fnname(int val)				\
 	{							\
 		int i;						\
 		for (i = 0; i < ARRAY_SIZE(list); i++) {	\
 			if (list[i].type == val)		\
 				return list[i].name;		\
 		}						\
 		return "(unknown)";				\
+	}
 /*
  * Global properties
  */
 static const struct drm_prop_enum_list drm_dpms_enum_list[] = {
 	{ 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)
 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
  */
 static const struct drm_prop_enum_list drm_scaling_mode_enum_list[] = {
 	{ DRM_MODE_SCALE_NONE, "None" },
 	{ 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_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)
 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)
 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_ENUM_NAME_FN(drm_get_tv_select_name, drm_tv_select_enum_list)
 static const struct drm_prop_enum_list drm_tv_subconnector_enum_list[] = {
 	{ DRM_MODE_SUBCONNECTOR_Unknown,   "Unknown"   }, /* 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_ENUM_NAME_FN(drm_get_tv_subconnector_name,
 		 drm_tv_subconnector_enum_list)
 static const struct drm_prop_enum_list drm_dirty_info_enum_list[] = {
 	{ DRM_MODE_DIRTY_OFF,      "Off"      },
 	{ DRM_MODE_DIRTY_ON,       "On"       },
 	{ DRM_MODE_DIRTY_ANNOTATE, "Annotate" },
 };
 struct drm_conn_prop_enum_list {
 	int type;
 	const char *name;
 	struct ida ida;
 };
 /*
  * Connector and encoder types.
  */
 static struct drm_conn_prop_enum_list drm_connector_enum_list[] = {
 	{ 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_Composite, "Composite" },
 	{ DRM_MODE_CONNECTOR_SVIDEO, "SVIDEO" },
 	{ DRM_MODE_CONNECTOR_LVDS, "LVDS" },
 	{ DRM_MODE_CONNECTOR_Component, "Component" },
 	{ DRM_MODE_CONNECTOR_9PinDIN, "DIN" },
 	{ DRM_MODE_CONNECTOR_DisplayPort, "DP" },
 	{ DRM_MODE_CONNECTOR_HDMIA, "HDMI-A" },
 	{ DRM_MODE_CONNECTOR_HDMIB, "HDMI-B" },
 	{ DRM_MODE_CONNECTOR_TV, "TV" },
 	{ 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[] = {
 	{ 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[] = {
 	{ SubPixelUnknown, "Unknown" },
 	{ SubPixelHorizontalRGB, "Horizontal RGB" },
 	{ SubPixelHorizontalBGR, "Horizontal BGR" },
 	{ SubPixelVerticalRGB, "Vertical RGB" },
 	{ SubPixelVerticalBGR, "Vertical BGR" },
 	{ SubPixelNone, "None" },
 };
 void drm_connector_ida_init(void)
+{
 	int i;
 	for (i = 0; i < ARRAY_SIZE(drm_connector_enum_list); i++)
 		ida_init(&drm_connector_enum_list[i].ida);
+}
 void drm_connector_ida_destroy(void)
+{
 	int i;
 	for (i = 0; i < ARRAY_SIZE(drm_connector_enum_list); i++)
 		ida_destroy(&drm_connector_enum_list[i].ida);
+}
 /**
  * drm_get_connector_status_name - return a string for connector status
  * @status: connector status to compute name of
+ *
  * In contrast to the other drm_get_*_name functions this one here returns a
  * const pointer and hence is threadsafe.
  */
 const char *drm_get_connector_status_name(enum drm_connector_status status)
+{
 	if (status == connector_status_connected)
 		return "connected";
 	else if (status == connector_status_disconnected)
 		return "disconnected";
 	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)
+{
 	static char buf[32];
 	snprintf(buf, sizeof(buf),
 		 "%c%c%c%c %s-endian (0x%08x)",
 		 printable_char(format & 0xff),
 		 printable_char((format >> 8) & 0xff),
 		 printable_char((format >> 16) & 0xff),
 		 printable_char((format >> 24) & 0x7f),
 		 format & DRM_FORMAT_BIG_ENDIAN ? "big" : "little",
 		 format);
 	return buf;
+}
 EXPORT_SYMBOL(drm_get_format_name);
 /*
  * Internal function to assign a slot in the object idr and optionally
  * register the object into the idr.
  */
 static int drm_mode_object_get_reg(struct drm_device *dev,
 				   struct drm_mode_object *obj,
 				   uint32_t obj_type,
 				   bool register_obj)
+{
 	int ret;
 	idr_preload(GFP_KERNEL);
 	mutex_lock(&dev->mode_config.idr_mutex);
 	ret = idr_alloc(&dev->mode_config.crtc_idr, register_obj ? obj : NULL, 1, 0, GFP_KERNEL);
 	if (ret >= 0) {
 		/*
 		 * Set up the object linking under the protection of the idr
 		 * lock so that other users can't see inconsistent state.
 		 */
 		obj->id = ret;
 		obj->type = obj_type;
+	}
 	mutex_unlock(&dev->mode_config.idr_mutex);
 	idr_preload_end();
 	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:
  * Zero on success, error code on failure.
  */
 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
  * for reference counted modeset objects like framebuffers.
  */
 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->type == DRM_MODE_OBJECT_BLOB))
 		obj = NULL;
 	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
  * DRM_MODE_OBJECT_ANY (although that will simply return NULL
  * 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 || type == DRM_MODE_OBJECT_BLOB);
 	obj = _object_find(dev, id, type);
 	return obj;
+}
 EXPORT_SYMBOL(drm_mode_object_find);
 /**
  * drm_framebuffer_init - initialize a framebuffer
  * @dev: DRM device
  * @fb: framebuffer to be initialized
  * @funcs: ... with these functions
+ *
  * Allocates an ID for the framebuffer's parent mode object, sets its mode
  * functions & device file and adds it to the master fd list.
+ *
  * IMPORTANT:
  * 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:
  * 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)
+{
 	int ret;
 	mutex_lock(&dev->mode_config.fb_lock);
 	kref_init(&fb->refcount);
 	INIT_LIST_HEAD(&fb->filp_head);
 	fb->dev = dev;
 	fb->funcs = funcs;
 	ret = drm_mode_object_get(dev, &fb->base, DRM_MODE_OBJECT_FB);
 	if (ret)
 		goto out;
 	dev->mode_config.num_fb++;
 	list_add(&fb->head, &dev->mode_config.fb_list);
 out:
 	mutex_unlock(&dev->mode_config.fb_lock);
 	return ret;
+}
 EXPORT_SYMBOL(drm_framebuffer_init);
 /* dev->mode_config.fb_lock must be held! */
 static void __drm_framebuffer_unregister(struct drm_device *dev,
 					 struct drm_framebuffer *fb)
+{
 	mutex_lock(&dev->mode_config.idr_mutex);
 	idr_remove(&dev->mode_config.crtc_idr, fb->base.id);
 	mutex_unlock(&dev->mode_config.idr_mutex);
 	fb->base.id = 0;
+}
 static void drm_framebuffer_free(struct kref *kref)
+{
 	struct drm_framebuffer *fb =
 			container_of(kref, struct drm_framebuffer, refcount);
 	struct drm_device *dev = fb->dev;
 	/*
 	 * The lookup idr holds a weak reference, which has not necessarily been
 	 * removed at this point. Check for that.
 	 */
 	mutex_lock(&dev->mode_config.fb_lock);
 	if (fb->base.id) {
 		/* Mark fb as reaped and drop idr ref. */
 		__drm_framebuffer_unregister(dev, fb);
+	}
 	mutex_unlock(&dev->mode_config.fb_lock);
 	fb->funcs->destroy(fb);
+}
 static struct drm_framebuffer *__drm_framebuffer_lookup(struct drm_device *dev,
 							uint32_t id)
+{
 	struct drm_mode_object *obj = NULL;
 	struct drm_framebuffer *fb;
 	mutex_lock(&dev->mode_config.idr_mutex);
 	obj = idr_find(&dev->mode_config.crtc_idr, id);
 	if (!obj || (obj->type != DRM_MODE_OBJECT_FB) || (obj->id != id))
 		fb = NULL;
 	else
 		fb = obj_to_fb(obj);
 	mutex_unlock(&dev->mode_config.idr_mutex);
 	return fb;
+}
 /**
  * drm_framebuffer_lookup - look up a drm framebuffer and grab a reference
  * @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, using @drm_framebuffer_unreference.
  */
 struct drm_framebuffer *drm_framebuffer_lookup(struct drm_device *dev,
 					       uint32_t id)
+{
 	struct drm_framebuffer *fb;
 	mutex_lock(&dev->mode_config.fb_lock);
 	fb = __drm_framebuffer_lookup(dev, id);
 	if (fb) {
 		if (!kref_get_unless_zero(&fb->refcount))
 			fb = NULL;
+	}
 	mutex_unlock(&dev->mode_config.fb_lock);
 	return fb;
+}
 EXPORT_SYMBOL(drm_framebuffer_lookup);
 /**
  * drm_framebuffer_unreference - unref a framebuffer
  * @fb: framebuffer to unref
+ *
  * 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("%p: FB ID: %d (%d)\n", fb, fb->base.id, fb->refcount.kr_count);
 	kref_put(&fb->refcount, drm_framebuffer_free);
+}
 EXPORT_SYMBOL(drm_framebuffer_unreference);
 /**
  * drm_framebuffer_reference - incr the fb refcnt
  * @fb: framebuffer
+ *
  * This functions increments the fb's refcount.
  */
 void drm_framebuffer_reference(struct drm_framebuffer *fb)
+{
 	DRM_DEBUG("%p: FB ID: %d (%d)\n", fb, fb->base.id, fb->refcount.kr_count);
 	kref_get(&fb->refcount);
+}
 EXPORT_SYMBOL(drm_framebuffer_reference);
 /**
  * drm_framebuffer_unregister_private - unregister a private fb from the lookup idr
  * @fb: fb to unregister
+ *
  * Drivers need to call this when cleaning up driver-private framebuffers, e.g.
  * those used for fbdev. Note that the caller must hold a reference of it's own,
  * 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;
 	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);
 	mutex_unlock(&dev->mode_config.fb_lock);
+}
 EXPORT_SYMBOL(drm_framebuffer_unregister_private);
 /**
  * drm_framebuffer_cleanup - remove a framebuffer object
  * @fb: framebuffer to remove
+ *
  * Cleanup framebuffer. This function is intended to be used from the drivers
  * ->destroy callback. It can also be used to clean up driver private
  *  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.
+ *
  * Also, the framebuffer will not be removed from the lookup idr - for
  * user-created framebuffers this will happen in in the rmfb ioctl. For
  * driver-private objects (e.g. for fbdev) drivers need to explicitly call
  * drm_framebuffer_unregister_private.
  */
 void drm_framebuffer_cleanup(struct drm_framebuffer *fb)
+{
 	struct drm_device *dev = fb->dev;
 	mutex_lock(&dev->mode_config.fb_lock);
 	list_del(&fb->head);
 	dev->mode_config.num_fb--;
 	mutex_unlock(&dev->mode_config.fb_lock);
+}
 EXPORT_SYMBOL(drm_framebuffer_cleanup);
 /**
  * drm_framebuffer_remove - remove and unreference a framebuffer object
  * @fb: framebuffer to remove
+ *
  * Scans all the CRTCs and planes in @dev's mode_config.  If they're
  * using @fb, removes it, setting it to NULL. Then drops the reference to the
  * passed-in framebuffer. Might take the modeset locks.
+ *
  * Note that this function optimizes the cleanup away if the caller holds the
  * 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;
 	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));
 	/*
 	 * drm ABI mandates that we remove any deleted framebuffers from active
 	 * useage. But since most sane clients only remove framebuffers they no
 	 * longer need, try to optimize this away.
+	 *
 	 * Since we're holding a reference ourselves, observing a refcount of 1
 	 * means that we're the last holder and can skip it. Also, the refcount
 	 * can never increase from 1 again, so we don't need any barriers or
 	 * locks.
+	 *
 	 * Note that userspace could try to race with use and instate a new
 	 * usage _after_ we've cleared all current ones. End result will be an
 	 * in-use fb with fb-id == 0. Userspace is allowed to shoot its own foot
 	 * in this manner.
 	 */
 	if (!kref_exclusive_p(&fb->refcount)) {
 		drm_modeset_lock_all(dev);
 		/* remove from any CRTC */
 		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;
 				ret = drm_mode_set_config_internal(&set);
 				if (ret)
 					DRM_ERROR("failed to reset crtc %p when fb was deleted\n", crtc);
+			}
+		}
 		drm_for_each_plane(plane, dev) {
 			if (plane->fb == fb)
 				drm_plane_force_disable(plane);
+		}
 		drm_modeset_unlock_all(dev);
+	}
 	drm_framebuffer_unreference(fb);
+}
 EXPORT_SYMBOL(drm_framebuffer_remove);
 DEFINE_WW_CLASS(crtc_ww_class);
 /**
  * drm_crtc_init_with_planes - Initialise a new CRTC object with
  *    specified primary and cursor planes.
  * @dev: DRM device
  * @crtc: CRTC object to init
  * @primary: Primary plane for CRTC
  * @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:
  * 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,
 			      struct drm_plane *cursor,
 			      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;
 	drm_modeset_lock_init(&crtc->mutex);
 	ret = drm_mode_object_get(dev, &crtc->base, DRM_MODE_OBJECT_CRTC);
 	if (ret)
 		return ret;
 	crtc->base.properties = &crtc->properties;
 	list_add_tail(&crtc->head, &config->crtc_list);
 	config->num_crtc++;
 	crtc->primary = primary;
 	crtc->cursor = cursor;
 	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);
 /**
  * drm_crtc_cleanup - Clean up the core crtc usage
  * @crtc: CRTC to cleanup
+ *
  * This function cleans up @crtc and removes it from the DRM mode setting
  * core. Note that the function does *not* free the crtc structure itself,
  * this is the responsibility of the caller.
  */
 void drm_crtc_cleanup(struct drm_crtc *crtc)
+{
 	struct drm_device *dev = crtc->dev;
 	kfree(crtc->gamma_store);
 	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--;
 	WARN_ON(crtc->state && !crtc->funcs->atomic_destroy_state);
 	if (crtc->state && crtc->funcs->atomic_destroy_state)
 		crtc->funcs->atomic_destroy_state(crtc, crtc->state);
 	memset(crtc, 0, sizeof(*crtc));
+}
 EXPORT_SYMBOL(drm_crtc_cleanup);
 /**
  * drm_crtc_index - find the index of a registered CRTC
  * @crtc: CRTC to find index for
+ *
  * Given a registered CRTC, return the index of that CRTC within a DRM
  * device's list of CRTCs.
  */
 unsigned int drm_crtc_index(struct drm_crtc *crtc)
+{
 	unsigned int index = 0;
 	struct drm_crtc *tmp;
 	drm_for_each_crtc(tmp, crtc->dev) {
 		if (tmp == crtc)
 			return index;
 		index++;
+	}
 	BUG();
+}
 EXPORT_SYMBOL(drm_crtc_index);
 /*
  * drm_mode_remove - remove and free a mode
  * @connector: connector list to modify
  * @mode: mode to remove
+ *
  * Remove @mode from @connector's mode list, then free it.
  */
 static void drm_mode_remove(struct drm_connector *connector,
 			    struct drm_display_mode *mode)
+{
 	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;
 #ifdef __NetBSD__
 	const char *option;
 	prop_dictionary_t prop = device_properties(connector->dev->dev);
-	if (!prop_dictionary_get_cstring(prop, connector->name, &option))
+	if (!prop_dictionary_get_string(prop, connector->name, &option))
 		return;
 #else
 	char *option = NULL;
 	if (fb_get_options(connector->name, &option))
 		return;
 #endif
 	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" : "");
+}
 /**
  * drm_connector_init - Init a preallocated connector
  * @dev: DRM device
  * @connector: the connector to init
  * @funcs: callbacks for this connector
  * @connector_type: user visible type of the connector
+ *
  * Initialises a preallocated connector. Connectors should be
  * subclassed as part of driver connector objects.
+ *
  * 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,
 		       int connector_type)
+{
 	struct drm_mode_config *config = &dev->mode_config;
 	int ret;
 	struct ida *connector_ida =
 		&drm_connector_enum_list[connector_type].ida;
 	drm_modeset_lock_all(dev);
 	ret = drm_mode_object_get_reg(dev, &connector->base, DRM_MODE_OBJECT_CONNECTOR, false);
 	if (ret)
 		goto out_unlock;
 	connector->base.properties = &connector->properties;
 	connector->dev = dev;
 	connector->kdev = 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;
+	}
 	connector->name =
 		kasprintf(GFP_KERNEL, "%s-%d",
 			  drm_connector_enum_list[connector_type].name,
 			  connector->connector_type_id);
 	if (!connector->name) {
 		ret = -ENOMEM;
 		goto out_put;
+	}
 	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, &config->connector_list);
 	config->num_connector++;
 	if (connector_type != DRM_MODE_CONNECTOR_VIRTUAL)
 		drm_object_attach_property(&connector->base,
 					      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, config->prop_crtc_id, 0);
+	}
 	connector->debugfs_entry = NULL;
 out_put:
 	if (ret)
 		drm_mode_object_put(dev, &connector->base);
 out_unlock:
 	drm_modeset_unlock_all(dev);
 	return ret;
+}
 EXPORT_SYMBOL(drm_connector_init);
 /**
  * drm_connector_cleanup - cleans up an initialised connector
  * @connector: connector to cleanup
+ *
  * Cleans up the connector but doesn't free the object.
  */
 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,
 		   connector->connector_type_id);
 	kfree(connector->display_info.bus_formats);
 	drm_mode_object_put(dev, &connector->base);
 	kfree(connector->name);
 	connector->name = NULL;
 	list_del(&connector->head);
 	dev->mode_config.num_connector--;
 	WARN_ON(connector->state && !connector->funcs->atomic_destroy_state);
 	if (connector->state && connector->funcs->atomic_destroy_state)
 		connector->funcs->atomic_destroy_state(connector,
 						       connector->state);
 	memset(connector, 0, sizeof(*connector));
+}
 EXPORT_SYMBOL(drm_connector_cleanup);
 /**
  * drm_connector_index - find the index of a registered connector
  * @connector: connector to find index for
+ *
  * Given a registered connector, return the index of that connector within a DRM
  * device's list of connectors.
  */
 unsigned int drm_connector_index(struct drm_connector *connector)
+{
 	unsigned int index = 0;
 	struct drm_connector *tmp;
 	struct drm_mode_config *config = &connector->dev->mode_config;
 	WARN_ON(!drm_modeset_is_locked(&config->connection_mutex));
 	drm_for_each_connector(tmp, connector->dev) {
 		if (tmp == connector)
 			return index;
 		index++;
+	}
 	BUG();
+}
 EXPORT_SYMBOL(drm_connector_index);
 /**
  * drm_connector_register - register a connector
  * @connector: the connector to register
+ *
  * Register userspace interfaces for a connector
+ *
  * Returns:
  * Zero on success, error code on failure.
  */
 int drm_connector_register(struct drm_connector *connector)
+{
 #ifndef __NetBSD__		/* XXX sysfs, debugfs */
 	int ret;
 #endif
 	drm_mode_object_register(connector->dev, &connector->base);
 #ifndef __NetBSD__		/* XXX sysfs, debugfs */
 	ret = drm_sysfs_connector_add(connector);
 	if (ret)
 		return ret;
 	ret = drm_debugfs_connector_add(connector);
 	if (ret) {
 		drm_sysfs_connector_remove(connector);
 		return ret;
+	}
 #endif
 	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)
+{
 #ifndef __NetBSD__		/* XXX sysfs, debugfs */
 	drm_sysfs_connector_remove(connector);
 	drm_debugfs_connector_remove(connector);
 #endif
+}
 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
  * ->disconnect callback.
  */
 void drm_connector_unplug_all(struct drm_device *dev)
+{
 	struct drm_connector *connector;
 	/* 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_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)
+{
 	int ret;
 	drm_modeset_lock_all(dev);
 	ret = drm_mode_object_get(dev, &encoder->base, DRM_MODE_OBJECT_ENCODER);
 	if (ret)
 		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) {
 		ret = -ENOMEM;
 		goto out_put;
+	}
 	list_add_tail(&encoder->head, &dev->mode_config.encoder_list);
 	dev->mode_config.num_encoder++;
 out_put:
 	if (ret)
 		drm_mode_object_put(dev, &encoder->base);
 out_unlock:
 	drm_modeset_unlock_all(dev);
 	return ret;
+}
 EXPORT_SYMBOL(drm_encoder_init);
 /**
  * drm_encoder_cleanup - cleans up an initialised encoder
  * @encoder: encoder to cleanup
+ *
  * 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--;
 	drm_modeset_unlock_all(dev);
 	memset(encoder, 0, sizeof(*encoder));
+}
 EXPORT_SYMBOL(drm_encoder_cleanup);
 /**
  * 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
  * @type: type of plane (overlay, primary, cursor)
+ *
  * Initializes a plane object of type @type.
+ *
  * Returns:
  * Zero on success, error code on failure.
  */
 int drm_universal_plane_init(struct drm_device *dev, struct drm_plane *plane,
 			     unsigned long possible_crtcs,
 			     const struct drm_plane_funcs *funcs,
 			     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)
 		return ret;
 	drm_modeset_lock_init(&plane->mutex);
 	plane->base.properties = &plane->properties;
 	plane->dev = dev;
 	plane->funcs = funcs;
 	plane->format_types = kmalloc_array(format_count, sizeof(uint32_t),
 					    GFP_KERNEL);
 	if (!plane->format_types) {
 		DRM_DEBUG_KMS("out of memory when allocating plane\n");
 		drm_mode_object_put(dev, &plane->base);
 		return -ENOMEM;
+	}
 	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, &config->plane_list);
 	config->num_total_plane++;
 	if (plane->type == DRM_PLANE_TYPE_OVERLAY)
 		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);
 		drm_object_attach_property(&plane->base, config->prop_src_h, 0);
+	}
 	return 0;
+}
 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, unsigned int format_count,
 		   bool is_primary)
+{
 	enum drm_plane_type type;
 	type = is_primary ? DRM_PLANE_TYPE_PRIMARY : DRM_PLANE_TYPE_OVERLAY;
 	return drm_universal_plane_init(dev, plane, possible_crtcs, funcs,
 					formats, format_count, type);
+}
 EXPORT_SYMBOL(drm_plane_init);
 /**
  * drm_plane_cleanup - Clean up the core plane usage
  * @plane: plane to cleanup
+ *
  * This function cleans up @plane and removes it from the DRM mode setting
  * core. Note that the function does *not* free the plane structure itself,
  * this is the responsibility of the caller.
  */
 void drm_plane_cleanup(struct drm_plane *plane)
+{
 	struct drm_device *dev = plane->dev;
 	drm_modeset_lock_all(dev);
 	kfree(plane->format_types);
 	drm_mode_object_put(dev, &plane->base);
 	BUG_ON(list_empty(&plane->head));
 	list_del(&plane->head);
 	dev->mode_config.num_total_plane--;
 	if (plane->type == DRM_PLANE_TYPE_OVERLAY)
 		dev->mode_config.num_overlay_plane--;
 	drm_modeset_unlock_all(dev);
 	WARN_ON(plane->state && !plane->funcs->atomic_destroy_state);
 	if (plane->state && plane->funcs->atomic_destroy_state)
 		plane->funcs->atomic_destroy_state(plane, plane->state);
 	drm_modeset_lock_fini(&plane->mutex);
 	memset(plane, 0, sizeof(*plane));
+}
 EXPORT_SYMBOL(drm_plane_cleanup);
 /**
  * drm_plane_index - find the index of a registered plane
  * @plane: plane to find index for
+ *
  * Given a registered plane, return the index of that CRTC within a DRM
  * device's list of planes.
  */
 unsigned int drm_plane_index(struct drm_plane *plane)
+{
 	unsigned int index = 0;
 	struct drm_plane *tmp;
 	drm_for_each_plane(tmp, plane->dev) {
 		if (tmp == plane)
 			return index;
 		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.
+ *
  * Used when the plane's current framebuffer is destroyed,
  * and when restoring fbdev mode.
  */
 void drm_plane_force_disable(struct drm_plane *plane)
+{
 	int ret;
 	if (!plane->fb)
 		return;
 	plane->old_fb = plane->fb;
 	ret = plane->funcs->disable_plane(plane);
 	if (ret) {
 		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);
 	plane->old_fb = NULL;
 	plane->fb = NULL;
 	plane->crtc = NULL;
+}
 EXPORT_SYMBOL(drm_plane_force_disable);
 static int drm_mode_create_standard_properties(struct drm_device *dev)
+{
 	struct drm_property *prop;
 	/*
 	 * Standard properties (apply to all connectors)
 	 */
 	prop = drm_property_create(dev, DRM_MODE_PROP_BLOB |
 				   DRM_MODE_PROP_IMMUTABLE,
 				   "EDID", 0);
 	if (!prop)
 		return -ENOMEM;
 	dev->mode_config.edid_property = prop;
 	prop = drm_property_create_enum(dev, 0,
 				   "DPMS", drm_dpms_enum_list,
 				   ARRAY_SIZE(drm_dpms_enum_list));
 	if (!prop)
 		return -ENOMEM;
 	dev->mode_config.dpms_property = prop;
 	prop = drm_property_create(dev,
 				   DRM_MODE_PROP_BLOB |
 				   DRM_MODE_PROP_IMMUTABLE,
 				   "PATH", 0);
 	if (!prop)
 		return -ENOMEM;
 	dev->mode_config.path_property = prop;
 	prop = drm_property_create(dev,
 				   DRM_MODE_PROP_BLOB |
 				   DRM_MODE_PROP_IMMUTABLE,
 				   "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;
 	prop = drm_property_create(dev,
 			DRM_MODE_PROP_ATOMIC | DRM_MODE_PROP_BLOB,
 			"MODE_ID", 0);
 	if (!prop)
 		return -ENOMEM;
 	dev->mode_config.prop_mode_id = prop;
 	return 0;
+}
 /**
  * drm_mode_create_dvi_i_properties - create DVI-I specific connector properties
  * @dev: DRM device
+ *
  * Called by a driver the first time a DVI-I connector is made.
  */
 int drm_mode_create_dvi_i_properties(struct drm_device *dev)
+{
 	struct drm_property *dvi_i_selector;
 	struct drm_property *dvi_i_subconnector;
 	if (dev->mode_config.dvi_i_select_subconnector_property)
 		return 0;
 	dvi_i_selector =
 		drm_property_create_enum(dev, 0,
 				    "select subconnector",
 				    drm_dvi_i_select_enum_list,
 				    ARRAY_SIZE(drm_dvi_i_select_enum_list));
 	dev->mode_config.dvi_i_select_subconnector_property = dvi_i_selector;
 	dvi_i_subconnector = drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE,
 				    "subconnector",
 				    drm_dvi_i_subconnector_enum_list,
 				    ARRAY_SIZE(drm_dvi_i_subconnector_enum_list));
 	dev->mode_config.dvi_i_subconnector_property = dvi_i_subconnector;
 	return 0;
+}
 EXPORT_SYMBOL(drm_mode_create_dvi_i_properties);
 /**
  * drm_create_tv_properties - create TV specific connector properties
  * @dev: DRM device
  * @num_modes: number of different TV formats (modes) supported
  * @modes: array of pointers to strings containing name of each format
+ *
  * Called by a driver's TV initialization routine, this function creates
  * the TV specific connector properties for a given device.  Caller is
  * responsible for allocating a list of format names and passing them to
  * this routine.
  */
 int drm_mode_create_tv_properties(struct drm_device *dev,
 				  unsigned int num_modes,
 				  const char * const modes[])
+{
 	struct drm_property *tv_selector;
 	struct drm_property *tv_subconnector;
 	unsigned int i;
 	if (dev->mode_config.tv_select_subconnector_property)
 		return 0;
 	/*
 	 * Basic connector properties
 	 */
 	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)
 		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);
 	if (!dev->mode_config.tv_left_margin_property)
 		goto nomem;
 	dev->mode_config.tv_right_margin_property =
 		drm_property_create_range(dev, 0, "right margin", 0, 100);
 	if (!dev->mode_config.tv_right_margin_property)
 		goto nomem;
 	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_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_mode_property =
 		drm_property_create(dev, DRM_MODE_PROP_ENUM,
 				    "mode", num_modes);
 	if (!dev->mode_config.tv_mode_property)
 		goto nomem;
 	for (i = 0; i < num_modes; i++)
 		drm_property_add_enum(dev->mode_config.tv_mode_property, i,
 				      i, modes[i]);
 	dev->mode_config.tv_brightness_property =
 		drm_property_create_range(dev, 0, "brightness", 0, 100);
 	if (!dev->mode_config.tv_brightness_property)
 		goto nomem;
 	dev->mode_config.tv_contrast_property =
 		drm_property_create_range(dev, 0, "contrast", 0, 100);
 	if (!dev->mode_config.tv_contrast_property)
 		goto nomem;
 	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)
 		goto nomem;
 	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_saturation_property =
 		drm_property_create_range(dev, 0, "saturation", 0, 100);
 	if (!dev->mode_config.tv_saturation_property)
 		goto nomem;
 	dev->mode_config.tv_hue_property =
 		drm_property_create_range(dev, 0, "hue", 0, 100);
 	if (!dev->mode_config.tv_hue_property)
 		goto nomem;
 	return 0;
 nomem:
 	return -ENOMEM;
+}
 EXPORT_SYMBOL(drm_mode_create_tv_properties);
 /**
  * drm_mode_create_scaling_mode_property - create scaling mode property
  * @dev: DRM device
+ *
  * Called by a driver the first time it's needed, must be attached to desired
  * connectors.
  */
 int drm_mode_create_scaling_mode_property(struct drm_device *dev)
+{
 	struct drm_property *scaling_mode;
 	if (dev->mode_config.scaling_mode_property)
 		return 0;
 	scaling_mode =
 		drm_property_create_enum(dev, 0, "scaling mode",
 				drm_scaling_mode_enum_list,
 				    ARRAY_SIZE(drm_scaling_mode_enum_list));
 	dev->mode_config.scaling_mode_property = scaling_mode;
 	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, negative 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
  * connectors.
  */
 int drm_mode_create_dirty_info_property(struct drm_device *dev)
+{
 	struct drm_property *dirty_info;
 	if (dev->mode_config.dirty_info_property)
 		return 0;
 	dirty_info =
 		drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE,
 				    "dirty",
 				    drm_dirty_info_enum_list,
 				    ARRAY_SIZE(drm_dirty_info_enum_list));
 	dev->mode_config.dirty_info_property = dirty_info;
 	return 0;
+}
 EXPORT_SYMBOL(drm_mode_create_dirty_info_property);
 /**
  * drm_mode_create_suggested_offset_properties - create suggests offset properties
  * @dev: DRM device
+ *
  * Create the the suggested x/y offset property for connectors.
  */
 int drm_mode_create_suggested_offset_properties(struct drm_device *dev)
+{
 	if (dev->mode_config.suggested_x_property && dev->mode_config.suggested_y_property)
 		return 0;
 	dev->mode_config.suggested_x_property =
 		drm_property_create_range(dev, DRM_MODE_PROP_IMMUTABLE, "suggested X", 0, 0xffffffff);
 	dev->mode_config.suggested_y_property =
 		drm_property_create_range(dev, DRM_MODE_PROP_IMMUTABLE, "suggested Y", 0, 0xffffffff);
 	if (dev->mode_config.suggested_x_property == NULL ||
 	    dev->mode_config.suggested_y_property == NULL)
 		return -ENOMEM;
 	return 0;
+}
 EXPORT_SYMBOL(drm_mode_create_suggested_offset_properties);
 /**
  * drm_mode_getresources - get graphics configuration
  * @dev: drm device for the ioctl
  * @data: data pointer for the ioctl
  * @file_priv: drm file for the ioctl call
+ *
  * Construct a set of configuration description structures and return
  * them to the user, including CRTC, connector and framebuffer configuration.
+ *
  * Called by the user via ioctl.
+ *
  * Returns:
  * Zero on success, negative errno on failure.
  */
 int drm_mode_getresources(struct drm_device *dev, void *data,
 			  struct drm_file *file_priv)
+{
 	struct drm_mode_card_res *card_res = data;
 	struct list_head *lh;
 	struct drm_framebuffer *fb;
 	struct drm_connector *connector;
 	struct drm_crtc *crtc;
 	struct drm_encoder *encoder;
 	int ret = 0;
 	int connector_count = 0;
 	int crtc_count = 0;
 	int fb_count = 0;
 	int encoder_count = 0;
 	int copied = 0;
 	uint32_t __user *fb_id;
 	uint32_t __user *crtc_id;
 	uint32_t __user *connector_id;
 	uint32_t __user *encoder_id;
 	if (!drm_core_check_feature(dev, DRIVER_MODESET))
 		return -EINVAL;
 	mutex_lock(&file_priv->fbs_lock);
 	/*
 	 * For the non-control nodes we need to limit the list of resources
 	 * by IDs in the group list for this node
 	 */
 	list_for_each(lh, &file_priv->fbs)
 		fb_count++;
 	/* handle this in 4 parts */
 	/* FBs */
 	if (card_res->count_fbs >= fb_count) {
 		copied = 0;
 		fb_id = (uint32_t __user *)(unsigned long)card_res->fb_id_ptr;
 		list_for_each_entry(fb, &file_priv->fbs, filp_head) {
 			if (put_user(fb->base.id, fb_id + copied)) {
 				mutex_unlock(&file_priv->fbs_lock);
 				return -EFAULT;
+			}
 			copied++;
+		}
+	}
 	card_res->count_fbs = fb_count;
 	mutex_unlock(&file_priv->fbs_lock);
 	/* mode_config.mutex protects the connector list against e.g. DP MST
 	 * connector hot-adding. CRTC/Plane lists are invariant. */
 	mutex_lock(&dev->mode_config.mutex);
 	drm_for_each_crtc(crtc, dev)
 		crtc_count++;
 	drm_for_each_connector(connector, dev)
 		connector_count++;
 	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;
 		crtc_id = (uint32_t __user *)(unsigned long)card_res->crtc_id_ptr;
 		drm_for_each_crtc(crtc, dev) {
 			DRM_DEBUG_KMS("[CRTC:%d]\n", crtc->base.id);
 			if (put_user(crtc->base.id, crtc_id + copied)) {
 				ret = -EFAULT;
 				goto out;
+			}
 			copied++;
+		}