87 files changed, 1259 insertions, 1127 deletions

diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.h b/drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.h
index ec4036a09f3e..a625b9137da2 100644
--- a/drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.h
+++ b/drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.h
@@ -187,12 +187,12 @@ int init_pipelines(struct device_queue_manager *dqm,
 unsigned int get_first_pipe(struct device_queue_manager *dqm);
 unsigned int get_pipes_num(struct device_queue_manager *dqm);
 
-extern inline unsigned int get_sh_mem_bases_32(struct kfd_process_device *pdd)
+static inline unsigned int get_sh_mem_bases_32(struct kfd_process_device *pdd)
 {
         return (pdd->lds_base >> 16) & 0xFF;
 }
 
-extern inline unsigned int
+static inline unsigned int
 get_sh_mem_bases_nybble_64(struct kfd_process_device *pdd)
 {
         return (pdd->lds_base >> 60) & 0x0E;
diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_priv.h b/drivers/gpu/drm/amd/amdkfd/kfd_priv.h
index d0d5f4baf72d..80113c335966 100644
--- a/drivers/gpu/drm/amd/amdkfd/kfd_priv.h
+++ b/drivers/gpu/drm/amd/amdkfd/kfd_priv.h
@@ -617,10 +617,7 @@ int kgd2kfd_resume(struct kfd_dev *kfd);
 int kfd_init_apertures(struct kfd_process *process);
 
 /* Queue Context Management */
-inline uint32_t lower_32(uint64_t x);
-inline uint32_t upper_32(uint64_t x);
 struct cik_sdma_rlc_registers *get_sdma_mqd(void *mqd);
-inline uint32_t get_sdma_base_addr(struct cik_sdma_rlc_registers *m);
 
 int init_queue(struct queue **q, struct queue_properties properties);
 void uninit_queue(struct queue *q);
diff --git a/drivers/gpu/drm/arc/arcpgu_drv.c b/drivers/gpu/drm/arc/arcpgu_drv.c
index 381c5fcbf903..ccbdadb108dc 100644
--- a/drivers/gpu/drm/arc/arcpgu_drv.c
+++ b/drivers/gpu/drm/arc/arcpgu_drv.c
@@ -211,15 +211,8 @@ static int arcpgu_probe(struct platform_device *pdev)
         if (ret)
                 goto err_unload;
 
-        ret = drm_connector_register_all(drm);
-        if (ret)
-                goto err_unregister;
-
         return 0;
 
-err_unregister:
-        drm_dev_unregister(drm);
-
 err_unload:
         arcpgu_unload(drm);
 
@@ -233,7 +226,6 @@ static int arcpgu_remove(struct platform_device *pdev)
 {
         struct drm_device *drm = platform_get_drvdata(pdev);
 
-        drm_connector_unregister_all(drm);
         drm_dev_unregister(drm);
         arcpgu_unload(drm);
         drm_dev_unref(drm);
diff --git a/drivers/gpu/drm/armada/armada_drv.c b/drivers/gpu/drm/armada/armada_drv.c
index cb21c0b6374a..f5ebdd681445 100644
--- a/drivers/gpu/drm/armada/armada_drv.c
+++ b/drivers/gpu/drm/armada/armada_drv.c
@@ -189,7 +189,6 @@ static struct drm_driver armada_drm_driver = {
         .load                   = armada_drm_load,
         .lastclose              = armada_drm_lastclose,
         .unload                 = armada_drm_unload,
-        .set_busid              = drm_platform_set_busid,
         .get_vblank_counter     = drm_vblank_no_hw_counter,
         .enable_vblank          = armada_drm_enable_vblank,
         .disable_vblank         = armada_drm_disable_vblank,
diff --git a/drivers/gpu/drm/armada/armada_overlay.c b/drivers/gpu/drm/armada/armada_overlay.c
index 148e8a42b2c6..1ee707ef6b8d 100644
--- a/drivers/gpu/drm/armada/armada_overlay.c
+++ b/drivers/gpu/drm/armada/armada_overlay.c
@@ -121,6 +121,7 @@ armada_ovl_plane_update(struct drm_plane *plane, struct drm_crtc *crtc,
         int ret;
 
         ret = drm_plane_helper_check_update(plane, crtc, fb, &src, &dest, &clip,
+                                            BIT(DRM_ROTATE_0),
                                             0, INT_MAX, true, false, &visible);
         if (ret)
                 return ret;
diff --git a/drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_dc.c b/drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_dc.c
index 9ecf16c7911d..d4a3d61b7b06 100644
--- a/drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_dc.c
+++ b/drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_dc.c
@@ -691,13 +691,6 @@ static void atmel_hlcdc_dc_unload(struct drm_device *dev)
         destroy_workqueue(dc->wq);
 }
 
-static void atmel_hlcdc_dc_connector_unplug_all(struct drm_device *dev)
-{
-        mutex_lock(&dev->mode_config.mutex);
-        drm_connector_unregister_all(dev);
-        mutex_unlock(&dev->mode_config.mutex);
-}
-
 static void atmel_hlcdc_dc_lastclose(struct drm_device *dev)
 {
         struct atmel_hlcdc_dc *dc = dev->dev_private;
@@ -815,15 +808,8 @@ static int atmel_hlcdc_dc_drm_probe(struct platform_device *pdev)
         if (ret)
                 goto err_unload;
 
-        ret = drm_connector_register_all(ddev);
-        if (ret)
-                goto err_unregister;
-
         return 0;
 
-err_unregister:
-        drm_dev_unregister(ddev);
-
 err_unload:
         atmel_hlcdc_dc_unload(ddev);
 
@@ -837,7 +823,6 @@ static int atmel_hlcdc_dc_drm_remove(struct platform_device *pdev)
 {
         struct drm_device *ddev = platform_get_drvdata(pdev);
 
-        atmel_hlcdc_dc_connector_unplug_all(ddev);
         drm_dev_unregister(ddev);
         atmel_hlcdc_dc_unload(ddev);
         drm_dev_unref(ddev);
diff --git a/drivers/gpu/drm/drm_auth.c b/drivers/gpu/drm/drm_auth.c
index 50d0baa06db0..4153e8a193af 100644
--- a/drivers/gpu/drm/drm_auth.c
+++ b/drivers/gpu/drm/drm_auth.c
@@ -30,25 +30,36 @@
 
 #include <drm/drmP.h>
 #include "drm_internal.h"
+#include "drm_legacy.h"
 
 /**
- * drm_getmagic - Get unique magic of a client
- * @dev: DRM device to operate on
- * @data: ioctl data containing the drm_auth object
- * @file_priv: DRM file that performs the operation
+ * DOC: master and authentication
  *
- * This looks up the unique magic of the passed client and returns it. If the
- * client did not have a magic assigned, yet, a new one is registered. The magic
- * is stored in the passed drm_auth object.
+ * struct &drm_master is used to track groups of clients with open
+ * primary/legacy device nodes. For every struct &drm_file which has had at
+ * least once successfully became the device master (either through the
+ * SET_MASTER IOCTL, or implicitly through opening the primary device node when
+ * no one else is the current master that time) there exists one &drm_master.
+ * This is noted in the is_master member of &drm_file. All other clients have
+ * just a pointer to the &drm_master they are associated with.
  *
- * Returns: 0 on success, negative error code on failure.
+ * In addition only one &drm_master can be the current master for a &drm_device.
+ * It can be switched through the DROP_MASTER and SET_MASTER IOCTL, or
+ * implicitly through closing/openeing the primary device node. See also
+ * drm_is_current_master().
+ *
+ * Clients can authenticate against the current master (if it matches their own)
+ * using the GETMAGIC and AUTHMAGIC IOCTLs. Together with exchanging masters,
+ * this allows controlled access to the device for an entire group of mutually
+ * trusted clients.
  */
+
 int drm_getmagic(struct drm_device *dev, void *data, struct drm_file *file_priv)
 {
         struct drm_auth *auth = data;
         int ret = 0;
 
-        mutex_lock(&dev->struct_mutex);
+        mutex_lock(&dev->master_mutex);
         if (!file_priv->magic) {
                 ret = idr_alloc(&file_priv->master->magic_map, file_priv,
                                 1, 0, GFP_KERNEL);
@@ -56,23 +67,13 @@ int drm_getmagic(struct drm_device *dev, void *data, struct drm_file *file_priv)
                         file_priv->magic = ret;
         }
         auth->magic = file_priv->magic;
-        mutex_unlock(&dev->struct_mutex);
+        mutex_unlock(&dev->master_mutex);
 
         DRM_DEBUG("%u\n", auth->magic);
 
         return ret < 0 ? ret : 0;
 }
 
-/**
- * drm_authmagic - Authenticate client with a magic
- * @dev: DRM device to operate on
- * @data: ioctl data containing the drm_auth object
- * @file_priv: DRM file that performs the operation
- *
- * This looks up a DRM client by the passed magic and authenticates it.
- *
- * Returns: 0 on success, negative error code on failure.
- */
 int drm_authmagic(struct drm_device *dev, void *data,
                   struct drm_file *file_priv)
 {
@@ -81,13 +82,253 @@ int drm_authmagic(struct drm_device *dev, void *data,
 
         DRM_DEBUG("%u\n", auth->magic);
 
-        mutex_lock(&dev->struct_mutex);
+        mutex_lock(&dev->master_mutex);
         file = idr_find(&file_priv->master->magic_map, auth->magic);
         if (file) {
                 file->authenticated = 1;
                 idr_replace(&file_priv->master->magic_map, NULL, auth->magic);
         }
-        mutex_unlock(&dev->struct_mutex);
+        mutex_unlock(&dev->master_mutex);
 
         return file ? 0 : -EINVAL;
 }
+
+static struct drm_master *drm_master_create(struct drm_device *dev)
+{
+        struct drm_master *master;
+
+        master = kzalloc(sizeof(*master), GFP_KERNEL);
+        if (!master)
+                return NULL;
+
+        kref_init(&master->refcount);
+        spin_lock_init(&master->lock.spinlock);
+        init_waitqueue_head(&master->lock.lock_queue);
+        idr_init(&master->magic_map);
+        master->dev = dev;
+
+        return master;
+}
+
+static int drm_set_master(struct drm_device *dev, struct drm_file *fpriv,
+                          bool new_master)
+{
+        int ret = 0;
+
+        dev->master = drm_master_get(fpriv->master);
+        if (dev->driver->master_set) {
+                ret = dev->driver->master_set(dev, fpriv, new_master);
+                if (unlikely(ret != 0)) {
+                        drm_master_put(&dev->master);
+                }
+        }
+
+        return ret;
+}
+
+static int drm_new_set_master(struct drm_device *dev, struct drm_file *fpriv)
+{
+        struct drm_master *old_master;
+        int ret;
+
+        lockdep_assert_held_once(&dev->master_mutex);
+
+        old_master = fpriv->master;
+        fpriv->master = drm_master_create(dev);
+        if (!fpriv->master) {
+                fpriv->master = old_master;
+                return -ENOMEM;
+        }
+
+        if (dev->driver->master_create) {
+                ret = dev->driver->master_create(dev, fpriv->master);
+                if (ret)
+                        goto out_err;
+        }
+        fpriv->is_master = 1;
+        fpriv->authenticated = 1;
+
+        ret = drm_set_master(dev, fpriv, true);
+        if (ret)
+                goto out_err;
+
+        if (old_master)
+                drm_master_put(&old_master);
+
+        return 0;
+
+out_err:
+        /* drop references and restore old master on failure */
+        drm_master_put(&fpriv->master);
+        fpriv->master = old_master;
+
+        return ret;
+}
+
+int drm_setmaster_ioctl(struct drm_device *dev, void *data,
+                        struct drm_file *file_priv)
+{
+        int ret = 0;
+
+        mutex_lock(&dev->master_mutex);
+        if (drm_is_current_master(file_priv))
+                goto out_unlock;
+
+        if (dev->master) {
+                ret = -EINVAL;
+                goto out_unlock;
+        }
+
+        if (!file_priv->master) {
+                ret = -EINVAL;
+                goto out_unlock;
+        }
+
+        if (!file_priv->is_master) {
+                ret = drm_new_set_master(dev, file_priv);
+                goto out_unlock;
+        }
+
+        ret = drm_set_master(dev, file_priv, false);
+out_unlock:
+        mutex_unlock(&dev->master_mutex);
+        return ret;
+}
+
+static void drm_drop_master(struct drm_device *dev,
+                            struct drm_file *fpriv)
+{
+        if (dev->driver->master_drop)
+                dev->driver->master_drop(dev, fpriv);
+        drm_master_put(&dev->master);
+}
+
+int drm_dropmaster_ioctl(struct drm_device *dev, void *data,
+                         struct drm_file *file_priv)
+{
+        int ret = -EINVAL;
+
+        mutex_lock(&dev->master_mutex);
+        if (!drm_is_current_master(file_priv))
+                goto out_unlock;
+
+        if (!dev->master)
+                goto out_unlock;
+
+        ret = 0;
+        drm_drop_master(dev, file_priv);
+out_unlock:
+        mutex_unlock(&dev->master_mutex);
+        return ret;
+}
+
+int drm_master_open(struct drm_file *file_priv)
+{
+        struct drm_device *dev = file_priv->minor->dev;
+        int ret = 0;
+
+        /* if there is no current master make this fd it, but do not create
+         * any master object for render clients */
+        mutex_lock(&dev->master_mutex);
+        if (!dev->master)
+                ret = drm_new_set_master(dev, file_priv);
+        else
+                file_priv->master = drm_master_get(dev->master);
+        mutex_unlock(&dev->master_mutex);
+
+        return ret;
+}
+
+void drm_master_release(struct drm_file *file_priv)
+{
+        struct drm_device *dev = file_priv->minor->dev;
+        struct drm_master *master = file_priv->master;
+
+        mutex_lock(&dev->master_mutex);
+        if (file_priv->magic)
+                idr_remove(&file_priv->master->magic_map, file_priv->magic);
+
+        if (!drm_is_current_master(file_priv))
+                goto out;
+
+        if (!drm_core_check_feature(dev, DRIVER_MODESET)) {
+                /*
+                 * Since the master is disappearing, so is the
+                 * possibility to lock.
+                 */
+                mutex_lock(&dev->struct_mutex);
+                if (master->lock.hw_lock) {
+                        if (dev->sigdata.lock == master->lock.hw_lock)
+                                dev->sigdata.lock = NULL;
+                        master->lock.hw_lock = NULL;
+                        master->lock.file_priv = NULL;
+                        wake_up_interruptible_all(&master->lock.lock_queue);
+                }
+                mutex_unlock(&dev->struct_mutex);
+        }
+
+        if (dev->master == file_priv->master)
+                drm_drop_master(dev, file_priv);
+out:
+        /* drop the master reference held by the file priv */
+        if (file_priv->master)
+                drm_master_put(&file_priv->master);
+        mutex_unlock(&dev->master_mutex);
+}
+
+/**
+ * drm_is_current_master - checks whether @priv is the current master
+ * @fpriv: DRM file private
+ *
+ * Checks whether @fpriv is current master on its device. This decides whether a
+ * client is allowed to run DRM_MASTER IOCTLs.
+ *
+ * Most of the modern IOCTL which require DRM_MASTER are for kernel modesetting
+ * - the current master is assumed to own the non-shareable display hardware.
+ */
+bool drm_is_current_master(struct drm_file *fpriv)
+{
+        return fpriv->is_master && fpriv->master == fpriv->minor->dev->master;
+}
+EXPORT_SYMBOL(drm_is_current_master);
+
+/**
+ * drm_master_get - reference a master pointer
+ * @master: struct &drm_master
+ *
+ * Increments the reference count of @master and returns a pointer to @master.
+ */
+struct drm_master *drm_master_get(struct drm_master *master)
+{
+        kref_get(&master->refcount);
+        return master;
+}
+EXPORT_SYMBOL(drm_master_get);
+
+static void drm_master_destroy(struct kref *kref)
+{
+        struct drm_master *master = container_of(kref, struct drm_master, refcount);
+        struct drm_device *dev = master->dev;
+
+        if (dev->driver->master_destroy)
+                dev->driver->master_destroy(dev, master);
+
+        drm_legacy_master_rmmaps(dev, master);
+
+        idr_destroy(&master->magic_map);
+        kfree(master->unique);
+        kfree(master);
+}
+
+/**
+ * drm_master_put - unreference and clear a master pointer
+ * @master: pointer to a pointer of struct &drm_master
+ *
+ * This decrements the &drm_master behind @master and sets it to NULL.
+ */
+void drm_master_put(struct drm_master **master)
+{
+        kref_put(&(*master)->refcount, drm_master_destroy);
+        *master = NULL;
+}
+EXPORT_SYMBOL(drm_master_put);
diff --git a/drivers/gpu/drm/drm_bufs.c b/drivers/gpu/drm/drm_bufs.c
index 9b34158c0f77..c3a12cd8bd0d 100644
--- a/drivers/gpu/drm/drm_bufs.c
+++ b/drivers/gpu/drm/drm_bufs.c
@@ -51,7 +51,7 @@ static struct drm_map_list *drm_find_matching_map(struct drm_device *dev,
                  */
                 if (!entry->map ||
                     map->type != entry->map->type ||
-                    entry->master != dev->primary->master)
+                    entry->master != dev->master)
                         continue;
                 switch (map->type) {
                 case _DRM_SHM:
@@ -245,12 +245,12 @@ static int drm_addmap_core(struct drm_device * dev, resource_size_t offset,
                 map->offset = (unsigned long)map->handle;
                 if (map->flags & _DRM_CONTAINS_LOCK) {
                         /* Prevent a 2nd X Server from creating a 2nd lock */
-                        if (dev->primary->master->lock.hw_lock != NULL) {
+                        if (dev->master->lock.hw_lock != NULL) {
                                 vfree(map->handle);
                                 kfree(map);
                                 return -EBUSY;
                         }
-                        dev->sigdata.lock = dev->primary->master->lock.hw_lock = map->handle;   /* Pointer to lock */
+                        dev->sigdata.lock = dev->master->lock.hw_lock = map->handle;    /* Pointer to lock */
                 }
                 break;
         case _DRM_AGP: {
@@ -356,7 +356,7 @@ static int drm_addmap_core(struct drm_device * dev, resource_size_t offset,
         mutex_unlock(&dev->struct_mutex);
 
         if (!(map->flags & _DRM_DRIVER))
-                list->master = dev->primary->master;
+                list->master = dev->master;
         *maplist = list;
         return 0;
 }
diff --git a/drivers/gpu/drm/drm_crtc.c b/drivers/gpu/drm/drm_crtc.c
index 4ec35f9e6de5..fd93e9c79d28 100644
--- a/drivers/gpu/drm/drm_crtc.c
+++ b/drivers/gpu/drm/drm_crtc.c
@@ -39,6 +39,7 @@
 #include <drm/drm_fourcc.h>
 #include <drm/drm_modeset_lock.h>
 #include <drm/drm_atomic.h>
+#include <drm/drm_auth.h>
 
 #include "drm_crtc_internal.h"
 #include "drm_internal.h"
@@ -608,6 +609,31 @@ static unsigned int drm_num_crtcs(struct drm_device *dev)
         return num;
 }
 
+static int drm_crtc_register_all(struct drm_device *dev)
+{
+        struct drm_crtc *crtc;
+        int ret = 0;
+
+        drm_for_each_crtc(crtc, dev) {
+                if (crtc->funcs->late_register)
+                        ret = crtc->funcs->late_register(crtc);
+                if (ret)
+                        return ret;
+        }
+
+        return 0;
+}
+
+static void drm_crtc_unregister_all(struct drm_device *dev)
+{
+        struct drm_crtc *crtc;
+
+        drm_for_each_crtc(crtc, dev) {
+                if (crtc->funcs->early_unregister)
+                        crtc->funcs->early_unregister(crtc);
+        }
+}
+
 /**
  * drm_crtc_init_with_planes - Initialise a new CRTC object with
  *    specified primary and cursor planes.
@@ -938,6 +964,12 @@ void drm_connector_cleanup(struct drm_connector *connector)
         struct drm_device *dev = connector->dev;
         struct drm_display_mode *mode, *t;
 
+        /* The connector should have been removed from userspace long before
+         * it is finally destroyed.
+         */
+        if (WARN_ON(connector->registered))
+                drm_connector_unregister(connector);
+
         if (connector->tile_group) {
                 drm_mode_put_tile_group(dev, connector->tile_group);
                 connector->tile_group = NULL;
@@ -984,19 +1016,34 @@ int drm_connector_register(struct drm_connector *connector)
 {
         int ret;
 
+        if (connector->registered)
+                return 0;
+
         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;
+                goto err_sysfs;
+        }
+
+        if (connector->funcs->late_register) {
+                ret = connector->funcs->late_register(connector);
+                if (ret)
+                        goto err_debugfs;
         }
 
         drm_mode_object_register(connector->dev, &connector->base);
 
+        connector->registered = true;
         return 0;
+
+err_debugfs:
+        drm_debugfs_connector_remove(connector);
+err_sysfs:
+        drm_sysfs_connector_remove(connector);
+        return ret;
 }
 EXPORT_SYMBOL(drm_connector_register);
 
@@ -1008,8 +1055,16 @@ EXPORT_SYMBOL(drm_connector_register);
  */
 void drm_connector_unregister(struct drm_connector *connector)
 {
+        if (!connector->registered)
+                return;
+
+        if (connector->funcs->early_unregister)
+                connector->funcs->early_unregister(connector);
+
         drm_sysfs_connector_remove(connector);
         drm_debugfs_connector_remove(connector);
+
+        connector->registered = false;
 }
 EXPORT_SYMBOL(drm_connector_unregister);
 
@@ -1018,9 +1073,9 @@ EXPORT_SYMBOL(drm_connector_unregister);
  * @dev: drm device
  *
  * This function registers all connectors in sysfs and other places so that
- * userspace can start to access them. Drivers can call it after calling
- * drm_dev_register() to complete the device registration, if they don't call
- * drm_connector_register() on each connector individually.
+ * userspace can start to access them. drm_connector_register_all() is called
+ * automatically from drm_dev_register() to complete the device registration,
+ * if they don't call drm_connector_register() on each connector individually.
  *
  * When a device is unplugged and should be removed from userspace access,
  * call drm_connector_unregister_all(), which is the inverse of this
@@ -1073,6 +1128,31 @@ void drm_connector_unregister_all(struct drm_device *dev)
 }
 EXPORT_SYMBOL(drm_connector_unregister_all);
 
+static int drm_encoder_register_all(struct drm_device *dev)
+{
+        struct drm_encoder *encoder;
+        int ret = 0;
+
+        drm_for_each_encoder(encoder, dev) {
+                if (encoder->funcs->late_register)
+                        ret = encoder->funcs->late_register(encoder);
+                if (ret)
+                        return ret;
+        }
+
+        return 0;
+}
+
+static void drm_encoder_unregister_all(struct drm_device *dev)
+{
+        struct drm_encoder *encoder;
+
+        drm_for_each_encoder(encoder, dev) {
+                if (encoder->funcs->early_unregister)
+                        encoder->funcs->early_unregister(encoder);
+        }
+}
+
 /**
  * drm_encoder_init - Init a preallocated encoder
  * @dev: drm device
@@ -1261,6 +1341,31 @@ int drm_universal_plane_init(struct drm_device *dev, struct drm_plane *plane,
 }
 EXPORT_SYMBOL(drm_universal_plane_init);
 
+static int drm_plane_register_all(struct drm_device *dev)
+{
+        struct drm_plane *plane;
+        int ret = 0;
+
+        drm_for_each_plane(plane, dev) {
+                if (plane->funcs->late_register)
+                        ret = plane->funcs->late_register(plane);
+                if (ret)
+                        return ret;
+        }
+
+        return 0;
+}
+
+static void drm_plane_unregister_all(struct drm_device *dev)
+{
+        struct drm_plane *plane;
+
+        drm_for_each_plane(plane, dev) {
+                if (plane->funcs->early_unregister)
+                        plane->funcs->early_unregister(plane);
+        }
+}
+
 /**
  * drm_plane_init - Initialize a legacy plane
  * @dev: DRM device
@@ -1383,6 +1488,46 @@ void drm_plane_force_disable(struct drm_plane *plane)
 }
 EXPORT_SYMBOL(drm_plane_force_disable);
 
+int drm_modeset_register_all(struct drm_device *dev)
+{
+        int ret;
+
+        ret = drm_plane_register_all(dev);
+        if (ret)
+                goto err_plane;
+
+        ret = drm_crtc_register_all(dev);
+        if  (ret)
+                goto err_crtc;
+
+        ret = drm_encoder_register_all(dev);
+        if (ret)
+                goto err_encoder;
+
+        ret = drm_connector_register_all(dev);
+        if (ret)
+                goto err_connector;
+
+        return 0;
+
+err_connector:
+        drm_encoder_unregister_all(dev);
+err_encoder:
+        drm_crtc_unregister_all(dev);
+err_crtc:
+        drm_plane_unregister_all(dev);
+err_plane:
+        return ret;
+}
+
+void drm_modeset_unregister_all(struct drm_device *dev)
+{
+        drm_connector_unregister_all(dev);
+        drm_encoder_unregister_all(dev);
+        drm_crtc_unregister_all(dev);
+        drm_plane_unregister_all(dev);
+}
+
 static int drm_mode_create_standard_properties(struct drm_device *dev)
 {
         struct drm_property *prop;
@@ -3499,7 +3644,7 @@ int drm_mode_getfb(struct drm_device *dev,
         r->bpp = fb->bits_per_pixel;
         r->pitch = fb->pitches[0];
         if (fb->funcs->create_handle) {
-                if (file_priv->is_master || capable(CAP_SYS_ADMIN) ||
+                if (drm_is_current_master(file_priv) || capable(CAP_SYS_ADMIN) ||
                     drm_is_control_client(file_priv)) {
                         ret = fb->funcs->create_handle(fb, file_priv,
                                                        &r->handle);
@@ -3656,6 +3801,13 @@ void drm_fb_release(struct drm_file *priv)
         }
 }
 
+static bool drm_property_type_valid(struct drm_property *property)
+{
+        if (property->flags & DRM_MODE_PROP_EXTENDED_TYPE)
+                return !(property->flags & DRM_MODE_PROP_LEGACY_TYPE);
+        return !!(property->flags & DRM_MODE_PROP_LEGACY_TYPE);
+}
+
 /**
  * drm_property_create - create a new property type
  * @dev: drm device
diff --git a/drivers/gpu/drm/drm_crtc_helper.c b/drivers/gpu/drm/drm_crtc_helper.c
index bf10d7046aa6..d61591274ff6 100644
--- a/drivers/gpu/drm/drm_crtc_helper.c
+++ b/drivers/gpu/drm/drm_crtc_helper.c
@@ -232,6 +232,9 @@ static void __drm_helper_disable_unused_functions(struct drm_device *dev)
  */
 void drm_helper_disable_unused_functions(struct drm_device *dev)
 {
+        if (drm_core_check_feature(dev, DRIVER_ATOMIC))
+                DRM_ERROR("Called for atomic driver, this is not what you want.\n");
+
         drm_modeset_lock_all(dev);
         __drm_helper_disable_unused_functions(dev);
         drm_modeset_unlock_all(dev);
diff --git a/drivers/gpu/drm/drm_crtc_internal.h b/drivers/gpu/drm/drm_crtc_internal.h
index a78c138282ea..47a500b90fd7 100644
--- a/drivers/gpu/drm/drm_crtc_internal.h
+++ b/drivers/gpu/drm/drm_crtc_internal.h
@@ -31,14 +31,100 @@
  * and are not exported to drivers.
  */
 
+
+/* drm_crtc.c */
+void drm_connector_ida_init(void);
+void drm_connector_ida_destroy(void);
 int drm_mode_object_get(struct drm_device *dev,
                         struct drm_mode_object *obj, uint32_t obj_type);
 void drm_mode_object_unregister(struct drm_device *dev,
                                 struct drm_mode_object *object);
+bool drm_property_change_valid_get(struct drm_property *property,
+                                   uint64_t value,
+                                   struct drm_mode_object **ref);
+void drm_property_change_valid_put(struct drm_property *property,
+                                   struct drm_mode_object *ref);
+
+int drm_plane_check_pixel_format(const struct drm_plane *plane,
+                                 u32 format);
+int drm_crtc_check_viewport(const struct drm_crtc *crtc,
+                            int x, int y,
+                            const struct drm_display_mode *mode,
+                            const struct drm_framebuffer *fb);
+
+void drm_fb_release(struct drm_file *file_priv);
+void drm_property_destroy_user_blobs(struct drm_device *dev,
+                                     struct drm_file *file_priv);
+
+/* dumb buffer support IOCTLs */
+int drm_mode_create_dumb_ioctl(struct drm_device *dev,
+                               void *data, struct drm_file *file_priv);
+int drm_mode_mmap_dumb_ioctl(struct drm_device *dev,
+                             void *data, struct drm_file *file_priv);
+int drm_mode_destroy_dumb_ioctl(struct drm_device *dev,
+                                void *data, struct drm_file *file_priv);
+
+/* framebuffer IOCTLs */
+extern int drm_mode_addfb(struct drm_device *dev,
+                          void *data, struct drm_file *file_priv);
+extern int drm_mode_addfb2(struct drm_device *dev,
+                           void *data, struct drm_file *file_priv);
+int drm_mode_rmfb(struct drm_device *dev,
+                         void *data, struct drm_file *file_priv);
+int drm_mode_getfb(struct drm_device *dev,
+                   void *data, struct drm_file *file_priv);
+int drm_mode_dirtyfb_ioctl(struct drm_device *dev,
+                           void *data, struct drm_file *file_priv);
+
+/* IOCTLs */
+int drm_mode_obj_get_properties_ioctl(struct drm_device *dev, void *data,
+                                      struct drm_file *file_priv);
+int drm_mode_obj_set_property_ioctl(struct drm_device *dev, void *data,
+                                    struct drm_file *file_priv);
+
+int drm_mode_getresources(struct drm_device *dev,
+                          void *data, struct drm_file *file_priv);
+int drm_mode_getplane_res(struct drm_device *dev, void *data,
+                          struct drm_file *file_priv);
+int drm_mode_getcrtc(struct drm_device *dev,
+                     void *data, struct drm_file *file_priv);
+int drm_mode_getconnector(struct drm_device *dev,
+                          void *data, struct drm_file *file_priv);
+int drm_mode_setcrtc(struct drm_device *dev,
+                     void *data, struct drm_file *file_priv);
+int drm_mode_getplane(struct drm_device *dev,
+                      void *data, struct drm_file *file_priv);
+int drm_mode_setplane(struct drm_device *dev,
+                      void *data, struct drm_file *file_priv);
+int drm_mode_cursor_ioctl(struct drm_device *dev,
+                          void *data, struct drm_file *file_priv);
+int drm_mode_cursor2_ioctl(struct drm_device *dev,
+                           void *data, struct drm_file *file_priv);
+int drm_mode_getproperty_ioctl(struct drm_device *dev,
+                               void *data, struct drm_file *file_priv);
+int drm_mode_getblob_ioctl(struct drm_device *dev,
+                           void *data, struct drm_file *file_priv);
+int drm_mode_createblob_ioctl(struct drm_device *dev,
+                              void *data, struct drm_file *file_priv);
+int drm_mode_destroyblob_ioctl(struct drm_device *dev,
+                               void *data, struct drm_file *file_priv);
+int drm_mode_connector_property_set_ioctl(struct drm_device *dev,
+                                          void *data, struct drm_file *file_priv);
+int drm_mode_getencoder(struct drm_device *dev,
+                        void *data, struct drm_file *file_priv);
+int drm_mode_gamma_get_ioctl(struct drm_device *dev,
+                             void *data, struct drm_file *file_priv);
+int drm_mode_gamma_set_ioctl(struct drm_device *dev,
+                             void *data, struct drm_file *file_priv);
+
+int drm_mode_page_flip_ioctl(struct drm_device *dev,
+                             void *data, struct drm_file *file_priv);
 
 /* drm_atomic.c */
 int drm_atomic_get_property(struct drm_mode_object *obj,
-                           struct drm_property *property, uint64_t *val);
+                            struct drm_property *property, uint64_t *val);
 int drm_mode_atomic_ioctl(struct drm_device *dev,
                           void *data, struct drm_file *file_priv);
 
+int drm_modeset_register_all(struct drm_device *dev);
+void drm_modeset_unregister_all(struct drm_device *dev);
diff --git a/drivers/gpu/drm/drm_debugfs.c b/drivers/gpu/drm/drm_debugfs.c
index 3bcf8e6a85b3..fa10cef2ba37 100644
--- a/drivers/gpu/drm/drm_debugfs.c
+++ b/drivers/gpu/drm/drm_debugfs.c
@@ -46,11 +46,8 @@
 
 static const struct drm_info_list drm_debugfs_list[] = {
         {"name", drm_name_info, 0},
-        {"vm", drm_vm_info, 0},
         {"clients", drm_clients_info, 0},
-        {"bufs", drm_bufs_info, 0},
         {"gem_names", drm_gem_name_info, DRIVER_GEM},
-        {"vma", drm_vma_info, 0},
 };
 #define DRM_DEBUGFS_ENTRIES ARRAY_SIZE(drm_debugfs_list)
 
diff --git a/drivers/gpu/drm/drm_dp_helper.c b/drivers/gpu/drm/drm_dp_helper.c
index eeaf5a7c3aa7..091053e995e5 100644
--- a/drivers/gpu/drm/drm_dp_helper.c
+++ b/drivers/gpu/drm/drm_dp_helper.c
@@ -708,8 +708,6 @@ static int drm_dp_i2c_xfer(struct i2c_adapter *adapter, struct i2c_msg *msgs,
 
         memset(&msg, 0, sizeof(msg));
 
-        mutex_lock(&aux->hw_mutex);
-
         for (i = 0; i < num; i++) {
                 msg.address = msgs[i].addr;
                 drm_dp_i2c_msg_set_request(&msg, &msgs[i]);
@@ -764,8 +762,6 @@ static int drm_dp_i2c_xfer(struct i2c_adapter *adapter, struct i2c_msg *msgs,
         msg.size = 0;
         (void)drm_dp_i2c_do_msg(aux, &msg);
 
-        mutex_unlock(&aux->hw_mutex);
-
         return err;
 }
 
@@ -774,22 +770,64 @@ static const struct i2c_algorithm drm_dp_i2c_algo = {
         .master_xfer = drm_dp_i2c_xfer,
 };
 
+static struct drm_dp_aux *i2c_to_aux(struct i2c_adapter *i2c)
+{
+        return container_of(i2c, struct drm_dp_aux, ddc);
+}
+
+static void lock_bus(struct i2c_adapter *i2c, unsigned int flags)
+{
+        mutex_lock(&i2c_to_aux(i2c)->hw_mutex);
+}
+
+static int trylock_bus(struct i2c_adapter *i2c, unsigned int flags)
+{
+        return mutex_trylock(&i2c_to_aux(i2c)->hw_mutex);
+}
+
+static void unlock_bus(struct i2c_adapter *i2c, unsigned int flags)
+{
+        mutex_unlock(&i2c_to_aux(i2c)->hw_mutex);
+}
+
 /**
- * drm_dp_aux_register() - initialise and register aux channel
+ * drm_dp_aux_init() - minimally initialise an aux channel
  * @aux: DisplayPort AUX channel
  *
- * Returns 0 on success or a negative error code on failure.
+ * If you need to use the drm_dp_aux's i2c adapter prior to registering it
+ * with the outside world, call drm_dp_aux_init() first. You must still
+ * call drm_dp_aux_register() once the connector has been registered to
+ * allow userspace access to the auxiliary DP channel.
  */
-int drm_dp_aux_register(struct drm_dp_aux *aux)
+void drm_dp_aux_init(struct drm_dp_aux *aux)
 {
-        int ret;
-
         mutex_init(&aux->hw_mutex);
 
         aux->ddc.algo = &drm_dp_i2c_algo;
         aux->ddc.algo_data = aux;
         aux->ddc.retries = 3;
 
+        aux->ddc.lock_bus = lock_bus;
+        aux->ddc.trylock_bus = trylock_bus;
+        aux->ddc.unlock_bus = unlock_bus;
+}
+EXPORT_SYMBOL(drm_dp_aux_init);
+
+/**
+ * drm_dp_aux_register() - initialise and register aux channel
+ * @aux: DisplayPort AUX channel
+ *
+ * Automatically calls drm_dp_aux_init() if this hasn't been done yet.
+ *
+ * Returns 0 on success or a negative error code on failure.
+ */
+int drm_dp_aux_register(struct drm_dp_aux *aux)
+{
+        int ret;
+
+        if (!aux->ddc.algo)
+                drm_dp_aux_init(aux);
+
         aux->ddc.class = I2C_CLASS_DDC;
         aux->ddc.owner = THIS_MODULE;
         aux->ddc.dev.parent = aux->dev;
diff --git a/drivers/gpu/drm/drm_drv.c b/drivers/gpu/drm/drm_drv.c
index 8b2582aeaab6..aead9ffcbe29 100644
--- a/drivers/gpu/drm/drm_drv.c
+++ b/drivers/gpu/drm/drm_drv.c
@@ -34,8 +34,10 @@
 #include <linux/slab.h>
 #include <drm/drmP.h>
 #include <drm/drm_core.h>
+#include "drm_crtc_internal.h"
 #include "drm_legacy.h"
 #include "drm_internal.h"
+#include "drm_crtc_internal.h"
 
 /*
  * drm_debug: Enable debug output.
@@ -93,114 +95,6 @@ void drm_ut_debug_printk(const char *function_name, const char *format, ...)
 }
 EXPORT_SYMBOL(drm_ut_debug_printk);
 
-struct drm_master *drm_master_create(struct drm_minor *minor)
-{
-        struct drm_master *master;
-
-        master = kzalloc(sizeof(*master), GFP_KERNEL);
-        if (!master)
-                return NULL;
-
-        kref_init(&master->refcount);
-        spin_lock_init(&master->lock.spinlock);
-        init_waitqueue_head(&master->lock.lock_queue);
-        idr_init(&master->magic_map);
-        master->minor = minor;
-
-        return master;
-}
-
-struct drm_master *drm_master_get(struct drm_master *master)
-{
-        kref_get(&master->refcount);
-        return master;
-}
-EXPORT_SYMBOL(drm_master_get);
-
-static void drm_master_destroy(struct kref *kref)
-{
-        struct drm_master *master = container_of(kref, struct drm_master, refcount);
-        struct drm_device *dev = master->minor->dev;
-
-        if (dev->driver->master_destroy)
-                dev->driver->master_destroy(dev, master);
-
-        drm_legacy_master_rmmaps(dev, master);
-
-        idr_destroy(&master->magic_map);
-        kfree(master->unique);
-        kfree(master);
-}
-
-void drm_master_put(struct drm_master **master)
-{
-        kref_put(&(*master)->refcount, drm_master_destroy);
-        *master = NULL;
-}
-EXPORT_SYMBOL(drm_master_put);
-
-int drm_setmaster_ioctl(struct drm_device *dev, void *data,
-                        struct drm_file *file_priv)
-{
-        int ret = 0;
-
-        mutex_lock(&dev->master_mutex);
-        if (file_priv->is_master)
-                goto out_unlock;
-
-        if (file_priv->minor->master) {
-                ret = -EINVAL;
-                goto out_unlock;
-        }
-
-        if (!file_priv->master) {
-                ret = -EINVAL;
-                goto out_unlock;
-        }
-
-        if (!file_priv->allowed_master) {
-                ret = drm_new_set_master(dev, file_priv);
-                goto out_unlock;
-        }
-
-        file_priv->minor->master = drm_master_get(file_priv->master);
-        file_priv->is_master = 1;
-        if (dev->driver->master_set) {
-                ret = dev->driver->master_set(dev, file_priv, false);
-                if (unlikely(ret != 0)) {
-                        file_priv->is_master = 0;
-                        drm_master_put(&file_priv->minor->master);
-                }
-        }
-
-out_unlock:
-        mutex_unlock(&dev->master_mutex);
-        return ret;
-}
-
-int drm_dropmaster_ioctl(struct drm_device *dev, void *data,
-                         struct drm_file *file_priv)
-{
-        int ret = -EINVAL;
-
-        mutex_lock(&dev->master_mutex);
-        if (!file_priv->is_master)
-                goto out_unlock;
-
-        if (!file_priv->minor->master)
-                goto out_unlock;
-
-        ret = 0;
-        if (dev->driver->master_drop)
-                dev->driver->master_drop(dev, file_priv, false);
-        drm_master_put(&file_priv->minor->master);
-        file_priv->is_master = 0;
-
-out_unlock:
-        mutex_unlock(&dev->master_mutex);
-        return ret;
-}
-
 /*
  * DRM Minors
  * A DRM device can provide several char-dev interfaces on the DRM-Major. Each
@@ -405,10 +299,9 @@ void drm_minor_release(struct drm_minor *minor)
  * callbacks implemented by the driver. The driver then needs to initialize all
  * the various subsystems for the drm device like memory management, vblank
  * handling, modesetting support and intial output configuration plus obviously
- * initialize all the corresponding hardware bits. An important part of this is
- * also calling drm_dev_set_unique() to set the userspace-visible unique name of
- * this device instance. Finally when everything is up and running and ready for
- * userspace the device instance can be published using drm_dev_register().
+ * initialize all the corresponding hardware bits. Finally when everything is up
+ * and running and ready for userspace the device instance can be published
+ * using drm_dev_register().
  *
  * There is also deprecated support for initalizing device instances using
  * bus-specific helpers and the ->load() callback. But due to
@@ -430,6 +323,14 @@ void drm_minor_release(struct drm_minor *minor)
  * dev_priv field of &drm_device.
  */
 
+static int drm_dev_set_unique(struct drm_device *dev, const char *name)
+{
+        kfree(dev->unique);
+        dev->unique = kstrdup(name, GFP_KERNEL);
+
+        return dev->unique ? 0 : -ENOMEM;
+}
+
 /**
  * drm_put_dev - Unregister and release a DRM device
  * @dev: DRM device
@@ -549,11 +450,12 @@ static void drm_fs_inode_free(struct inode *inode)
 }
 
 /**
- * drm_dev_alloc - Allocate new DRM device
- * @driver: DRM driver to allocate device for
+ * drm_dev_init - Initialise new DRM device
+ * @dev: DRM device
+ * @driver: DRM driver
  * @parent: Parent device object
  *
- * Allocate and initialize a new DRM device. No device registration is done.
+ * Initialize a new DRM device. No device registration is done.
  * Call drm_dev_register() to advertice the device to user space and register it
  * with other core subsystems. This should be done last in the device
  * initialization sequence to make sure userspace can't access an inconsistent
@@ -564,19 +466,18 @@ static void drm_fs_inode_free(struct inode *inode)
  *
  * Note that for purely virtual devices @parent can be NULL.
  *
+ * Drivers that do not want to allocate their own device struct
+ * embedding struct &drm_device can call drm_dev_alloc() instead.
+ *
  * RETURNS:
- * Pointer to new DRM device, or NULL if out of memory.
+ * 0 on success, or error code on failure.
  */
-struct drm_device *drm_dev_alloc(struct drm_driver *driver,
-                                 struct device *parent)
+int drm_dev_init(struct drm_device *dev,
+                 struct drm_driver *driver,
+                 struct device *parent)
 {
-        struct drm_device *dev;
         int ret;
 
-        dev = kzalloc(sizeof(*dev), GFP_KERNEL);
-        if (!dev)
-                return NULL;
-
         kref_init(&dev->ref);
         dev->dev = parent;
         dev->driver = driver;
@@ -617,7 +518,8 @@ struct drm_device *drm_dev_alloc(struct drm_driver *driver,
         if (ret)
                 goto err_minors;
 
-        if (drm_ht_create(&dev->map_hash, 12))
+        ret = drm_ht_create(&dev->map_hash, 12);
+        if (ret)
                 goto err_minors;
 
         drm_legacy_ctxbitmap_init(dev);
@@ -630,13 +532,13 @@ struct drm_device *drm_dev_alloc(struct drm_driver *driver,
                 }
         }
 
-        if (parent) {
-                ret = drm_dev_set_unique(dev, dev_name(parent));
-                if (ret)
-                        goto err_setunique;
-        }
+        /* Use the parent device name as DRM device unique identifier, but fall
+         * back to the driver name for virtual devices like vgem. */
+        ret = drm_dev_set_unique(dev, parent ? dev_name(parent) : driver->name);
+        if (ret)
+                goto err_setunique;
 
-        return dev;
+        return 0;
 
 err_setunique:
         if (drm_core_check_feature(dev, DRIVER_GEM))
@@ -651,8 +553,49 @@ err_minors:
         drm_fs_inode_free(dev->anon_inode);
 err_free:
         mutex_destroy(&dev->master_mutex);
-        kfree(dev);
-        return NULL;
+        return ret;
+}
+EXPORT_SYMBOL(drm_dev_init);
+
+/**
+ * drm_dev_alloc - Allocate new DRM device
+ * @driver: DRM driver to allocate device for
+ * @parent: Parent device object
+ *
+ * Allocate and initialize a new DRM device. No device registration is done.
+ * Call drm_dev_register() to advertice the device to user space and register it
+ * with other core subsystems. This should be done last in the device
+ * initialization sequence to make sure userspace can't access an inconsistent
+ * state.
+ *
+ * The initial ref-count of the object is 1. Use drm_dev_ref() and
+ * drm_dev_unref() to take and drop further ref-counts.
+ *
+ * Note that for purely virtual devices @parent can be NULL.
+ *
+ * Drivers that wish to subclass or embed struct &drm_device into their
+ * own struct should look at using drm_dev_init() instead.
+ *
+ * RETURNS:
+ * Pointer to new DRM device, or NULL if out of memory.
+ */
+struct drm_device *drm_dev_alloc(struct drm_driver *driver,
+                                 struct device *parent)
+{
+        struct drm_device *dev;
+        int ret;
+
+        dev = kzalloc(sizeof(*dev), GFP_KERNEL);
+        if (!dev)
+                return NULL;
+
+        ret = drm_dev_init(dev, driver, parent);
+        if (ret) {
+                kfree(dev);
+                return NULL;
+        }
+
+        return dev;
 }
 EXPORT_SYMBOL(drm_dev_alloc);
 
@@ -716,11 +659,7 @@ EXPORT_SYMBOL(drm_dev_unref);
  *
  * Register the DRM device @dev with the system, advertise device to user-space
  * and start normal device operation. @dev must be allocated via drm_dev_alloc()
- * previously. Right after drm_dev_register() the driver should call
- * drm_connector_register_all() to register all connectors in sysfs. This is
- * a separate call for backward compatibility with drivers still using
- * the deprecated ->load() callback, where connectors are registered from within
- * the ->load() callback.
+ * previously.
  *
  * Never call this twice on any device!
  *
@@ -757,6 +696,9 @@ int drm_dev_register(struct drm_device *dev, unsigned long flags)
                         goto err_minors;
         }
 
+        if (drm_core_check_feature(dev, DRIVER_MODESET))
+                drm_modeset_register_all(dev);
+
         ret = 0;
         goto out_unlock;
 
@@ -787,6 +729,9 @@ void drm_dev_unregister(struct drm_device *dev)
 
         drm_lastclose(dev);
 
+        if (drm_core_check_feature(dev, DRIVER_MODESET))
+                drm_modeset_unregister_all(dev);
+
         if (dev->driver->unload)
                 dev->driver->unload(dev);
 
@@ -804,26 +749,6 @@ void drm_dev_unregister(struct drm_device *dev)
 }
 EXPORT_SYMBOL(drm_dev_unregister);
 
-/**
- * drm_dev_set_unique - Set the unique name of a DRM device
- * @dev: device of which to set the unique name
- * @name: unique name
- *
- * Sets the unique name of a DRM device using the specified string. Drivers
- * can use this at driver probe time if the unique name of the devices they
- * drive is static.
- *
- * Return: 0 on success or a negative error code on failure.
- */
-int drm_dev_set_unique(struct drm_device *dev, const char *name)
-{
-        kfree(dev->unique);
-        dev->unique = kstrdup(name, GFP_KERNEL);
-
-        return dev->unique ? 0 : -ENOMEM;
-}
-EXPORT_SYMBOL(drm_dev_set_unique);
-
 /*
  * DRM Core
  * The DRM core module initializes all global DRM objects and makes them
diff --git a/drivers/gpu/drm/drm_fb_helper.c b/drivers/gpu/drm/drm_fb_helper.c
index 0bac5246e5a7..ce54e985d91b 100644
--- a/drivers/gpu/drm/drm_fb_helper.c
+++ b/drivers/gpu/drm/drm_fb_helper.c
@@ -464,7 +464,7 @@ static bool drm_fb_helper_is_bound(struct drm_fb_helper *fb_helper)
 
         /* Sometimes user space wants everything disabled, so don't steal the
          * display if there's a master. */
-        if (dev->primary->master)
+        if (lockless_dereference(dev->master))
                 return false;
 
         drm_for_each_crtc(crtc, dev) {
diff --git a/drivers/gpu/drm/drm_fops.c b/drivers/gpu/drm/drm_fops.c
index a27bc7cda975..323c238fcac7 100644
--- a/drivers/gpu/drm/drm_fops.c
+++ b/drivers/gpu/drm/drm_fops.c
@@ -40,6 +40,7 @@
 #include <linux/module.h>
 #include "drm_legacy.h"
 #include "drm_internal.h"
+#include "drm_crtc_internal.h"
 
 /* from BKL pushdown */
 DEFINE_MUTEX(drm_global_mutex);
@@ -168,60 +169,6 @@ static int drm_cpu_valid(void)
 }
 
 /*
- * drm_new_set_master - Allocate a new master object and become master for the
- * associated master realm.
- *
- * @dev: The associated device.
- * @fpriv: File private identifying the client.
- *
- * This function must be called with dev::struct_mutex held.
- * Returns negative error code on failure. Zero on success.
- */
-int drm_new_set_master(struct drm_device *dev, struct drm_file *fpriv)
-{
-        struct drm_master *old_master;
-        int ret;
-
-        lockdep_assert_held_once(&dev->master_mutex);
-
-        /* create a new master */
-        fpriv->minor->master = drm_master_create(fpriv->minor);
-        if (!fpriv->minor->master)
-                return -ENOMEM;
-
-        /* take another reference for the copy in the local file priv */
-        old_master = fpriv->master;
-        fpriv->master = drm_master_get(fpriv->minor->master);
-
-        if (dev->driver->master_create) {
-                ret = dev->driver->master_create(dev, fpriv->master);
-                if (ret)
-                        goto out_err;
-        }
-        if (dev->driver->master_set) {
-                ret = dev->driver->master_set(dev, fpriv, true);
-                if (ret)
-                        goto out_err;
-        }
-
-        fpriv->is_master = 1;
-        fpriv->allowed_master = 1;
-        fpriv->authenticated = 1;
-        if (old_master)
-                drm_master_put(&old_master);
-
-        return 0;
-
-out_err:
-        /* drop both references and restore old master on failure */
-        drm_master_put(&fpriv->minor->master);
-        drm_master_put(&fpriv->master);
-        fpriv->master = old_master;
-
-        return ret;
-}
-
-/*
  * Called whenever a process opens /dev/drm.
  *
  * \param filp file pointer.
@@ -283,19 +230,11 @@ static int drm_open_helper(struct file *filp, struct drm_minor *minor)
                         goto out_prime_destroy;
         }
 
-        /* if there is no current master make this fd it, but do not create
-         * any master object for render clients */
-        mutex_lock(&dev->master_mutex);
-        if (drm_is_primary_client(priv) && !priv->minor->master) {
-                /* create a new master */
-                ret = drm_new_set_master(dev, priv);
+        if (drm_is_primary_client(priv)) {
+                ret = drm_master_open(priv);
                 if (ret)
                         goto out_close;
-        } else if (drm_is_primary_client(priv)) {
-                /* get a reference to the master */
-                priv->master = drm_master_get(priv->minor->master);
         }
-        mutex_unlock(&dev->master_mutex);
 
         mutex_lock(&dev->filelist_mutex);
         list_add(&priv->lhead, &dev->filelist);
@@ -324,7 +263,6 @@ static int drm_open_helper(struct file *filp, struct drm_minor *minor)
         return 0;
 
 out_close:
-        mutex_unlock(&dev->master_mutex);
         if (dev->driver->postclose)
                 dev->driver->postclose(dev, priv);
 out_prime_destroy:
@@ -338,18 +276,6 @@ out_prime_destroy:
         return ret;
 }
 
-static void drm_master_release(struct drm_device *dev, struct file *filp)
-{
-        struct drm_file *file_priv = filp->private_data;
-
-        if (drm_legacy_i_have_hw_lock(dev, file_priv)) {
-                DRM_DEBUG("File %p released, freeing lock for context %d\n",
-                          filp, _DRM_LOCKING_CONTEXT(file_priv->master->lock.hw_lock->lock));
-                drm_legacy_lock_free(&file_priv->master->lock,
-                                     _DRM_LOCKING_CONTEXT(file_priv->master->lock.hw_lock->lock));
-        }
-}
-
 static void drm_events_release(struct drm_file *file_priv)
 {
         struct drm_device *dev = file_priv->minor->dev;
@@ -451,11 +377,6 @@ int drm_release(struct inode *inode, struct file *filp)
         list_del(&file_priv->lhead);
         mutex_unlock(&dev->filelist_mutex);
 
-        mutex_lock(&dev->struct_mutex);
-        if (file_priv->magic)
-                idr_remove(&file_priv->master->magic_map, file_priv->magic);
-        mutex_unlock(&dev->struct_mutex);
-
         if (dev->driver->preclose)
                 dev->driver->preclose(dev, file_priv);
 
@@ -468,9 +389,8 @@ int drm_release(struct inode *inode, struct file *filp)
                   (long)old_encode_dev(file_priv->minor->kdev->devt),
                   dev->open_count);
 
-        /* if the master has gone away we can't do anything with the lock */
-        if (file_priv->minor->master)
-                drm_master_release(dev, filp);
+        if (!drm_core_check_feature(dev, DRIVER_MODESET))
+                drm_legacy_lock_release(dev, filp);
 
         if (drm_core_check_feature(dev, DRIVER_HAVE_DMA))
                 drm_legacy_reclaim_buffers(dev, file_priv);
@@ -487,43 +407,12 @@ int drm_release(struct inode *inode, struct file *filp)
 
         drm_legacy_ctxbitmap_flush(dev, file_priv);
 
-        mutex_lock(&dev->master_mutex);
-
-        if (file_priv->is_master) {
-                struct drm_master *master = file_priv->master;
-
-                /*
-                 * Since the master is disappearing, so is the
-                 * possibility to lock.
-                 */
-                mutex_lock(&dev->struct_mutex);
-                if (master->lock.hw_lock) {
-                        if (dev->sigdata.lock == master->lock.hw_lock)
-                                dev->sigdata.lock = NULL;
-                        master->lock.hw_lock = NULL;
-                        master->lock.file_priv = NULL;
-                        wake_up_interruptible_all(&master->lock.lock_queue);
-                }
-                mutex_unlock(&dev->struct_mutex);
-
-                if (file_priv->minor->master == file_priv->master) {
-                        /* drop the reference held my the minor */
-                        if (dev->driver->master_drop)
-                                dev->driver->master_drop(dev, file_priv, true);
-                        drm_master_put(&file_priv->minor->master);
-                }
-        }
-
-        /* drop the master reference held by the file priv */
-        if (file_priv->master)
-                drm_master_put(&file_priv->master);
-        file_priv->is_master = 0;
-        mutex_unlock(&dev->master_mutex);
+        if (drm_is_primary_client(file_priv))
+                drm_master_release(file_priv);
 
         if (dev->driver->postclose)
                 dev->driver->postclose(dev, file_priv);
 
-
         if (drm_core_check_feature(dev, DRIVER_PRIME))
                 drm_prime_destroy_file_private(&file_priv->prime);
 
diff --git a/drivers/gpu/drm/drm_info.c b/drivers/gpu/drm/drm_info.c
index 5d469b2f26f4..9ae353f4dd06 100644
--- a/drivers/gpu/drm/drm_info.c
+++ b/drivers/gpu/drm/drm_info.c
@@ -50,106 +50,24 @@ int drm_name_info(struct seq_file *m, void *data)
         struct drm_info_node *node = (struct drm_info_node *) m->private;
         struct drm_minor *minor = node->minor;
         struct drm_device *dev = minor->dev;
-        struct drm_master *master = minor->master;
-        if (!master)
-                return 0;
-
-        if (master->unique) {
-                seq_printf(m, "%s %s %s\n",
-                           dev->driver->name,
-                           dev_name(dev->dev), master->unique);
-        } else {
-                seq_printf(m, "%s %s\n",
-                           dev->driver->name, dev_name(dev->dev));
-        }
-        return 0;
-}
-
-/**
- * Called when "/proc/dri/.../vm" is read.
- *
- * Prints information about all mappings in drm_device::maplist.
- */
-int drm_vm_info(struct seq_file *m, void *data)
-{
-        struct drm_info_node *node = (struct drm_info_node *) m->private;
-        struct drm_device *dev = node->minor->dev;
-        struct drm_local_map *map;
-        struct drm_map_list *r_list;
-
-        /* Hardcoded from _DRM_FRAME_BUFFER,
-           _DRM_REGISTERS, _DRM_SHM, _DRM_AGP, and
-           _DRM_SCATTER_GATHER and _DRM_CONSISTENT */
-        const char *types[] = { "FB", "REG", "SHM", "AGP", "SG", "PCI" };
-        const char *type;
-        int i;
-
-        mutex_lock(&dev->struct_mutex);
-        seq_printf(m, "slot      offset       size type flags    address mtrr\n\n");
-        i = 0;
-        list_for_each_entry(r_list, &dev->maplist, head) {
-                map = r_list->map;
-                if (!map)
-                        continue;
-                if (map->type < 0 || map->type > 5)
-                        type = "??";
-                else
-                        type = types[map->type];
-
-                seq_printf(m, "%4d 0x%016llx 0x%08lx %4.4s  0x%02x 0x%08lx ",
-                           i,
-                           (unsigned long long)map->offset,
-                           map->size, type, map->flags,
-                           (unsigned long) r_list->user_token);
-                if (map->mtrr < 0)
-                        seq_printf(m, "none\n");
-                else
-                        seq_printf(m, "%4d\n", map->mtrr);
-                i++;
-        }
-        mutex_unlock(&dev->struct_mutex);
-        return 0;
-}
+        struct drm_master *master;
 
-/**
- * Called when "/proc/dri/.../bufs" is read.
- */
-int drm_bufs_info(struct seq_file *m, void *data)
-{
-        struct drm_info_node *node = (struct drm_info_node *) m->private;
-        struct drm_device *dev = node->minor->dev;
-        struct drm_device_dma *dma;
-        int i, seg_pages;
-
-        mutex_lock(&dev->struct_mutex);
-        dma = dev->dma;
-        if (!dma) {
-                mutex_unlock(&dev->struct_mutex);
-                return 0;
-        }
-
-        seq_printf(m, " o     size count  free   segs pages    kB\n\n");
-        for (i = 0; i <= DRM_MAX_ORDER; i++) {
-                if (dma->bufs[i].buf_count) {
-                        seg_pages = dma->bufs[i].seg_count * (1 << dma->bufs[i].page_order);
-                        seq_printf(m, "%2d %8d %5d %5d %5d %5d %5ld\n",
-                                   i,
-                                   dma->bufs[i].buf_size,
-                                   dma->bufs[i].buf_count,
-                                   0,
-                                   dma->bufs[i].seg_count,
-                                   seg_pages,
-                                   seg_pages * PAGE_SIZE / 1024);
-                }
-        }
-        seq_printf(m, "\n");
-        for (i = 0; i < dma->buf_count; i++) {
-                if (i && !(i % 32))
-                        seq_printf(m, "\n");
-                seq_printf(m, " %d", dma->buflist[i]->list);
-        }
+        mutex_lock(&dev->master_mutex);
+        master = dev->master;
+        if (!master)
+                goto out_unlock;
+
+        seq_printf(m, "%s", dev->driver->name);
+        if (dev->dev)
+                seq_printf(m, " dev=%s", dev_name(dev->dev));
+        if (master && master->unique)
+                seq_printf(m, " master=%s", master->unique);
+        if (dev->unique)
+                seq_printf(m, " unique=%s", dev->unique);
         seq_printf(m, "\n");
-        mutex_unlock(&dev->struct_mutex);
+out_unlock:
+        mutex_unlock(&dev->master_mutex);
+
         return 0;
 }
 
@@ -184,7 +102,7 @@ int drm_clients_info(struct seq_file *m, void *data)
                            task ? task->comm : "<unknown>",
                            pid_vnr(priv->pid),
                            priv->minor->index,
-                           priv->is_master ? 'y' : 'n',
+                           drm_is_current_master(priv) ? 'y' : 'n',
                            priv->authenticated ? 'y' : 'n',
                            from_kuid_munged(seq_user_ns(m), priv->uid),
                            priv->magic);
@@ -194,7 +112,6 @@ int drm_clients_info(struct seq_file *m, void *data)
         return 0;
 }
 
-
 static int drm_gem_one_name_info(int id, void *ptr, void *data)
 {
         struct drm_gem_object *obj = ptr;
diff --git a/drivers/gpu/drm/drm_internal.h b/drivers/gpu/drm/drm_internal.h
index 902cf6a15212..b86dc9b921a5 100644
--- a/drivers/gpu/drm/drm_internal.h
+++ b/drivers/gpu/drm/drm_internal.h
@@ -29,15 +29,9 @@ extern struct mutex drm_global_mutex;
 void drm_lastclose(struct drm_device *dev);
 
 /* drm_pci.c */
-int drm_pci_set_unique(struct drm_device *dev,
-                       struct drm_master *master,
-                       struct drm_unique *u);
 int drm_irq_by_busid(struct drm_device *dev, void *data,
                      struct drm_file *file_priv);
 
-/* drm_vm.c */
-int drm_vma_info(struct seq_file *m, void *data);
-
 /* drm_prime.c */
 int drm_prime_handle_to_fd_ioctl(struct drm_device *dev, void *data,
                                  struct drm_file *file_priv);
@@ -51,8 +45,6 @@ void drm_prime_remove_buf_handle_locked(struct drm_prime_file_private *prime_fpr
 
 /* drm_info.c */
 int drm_name_info(struct seq_file *m, void *data);
-int drm_vm_info(struct seq_file *m, void *data);
-int drm_bufs_info(struct seq_file *m, void *data);
 int drm_clients_info(struct seq_file *m, void* data);
 int drm_gem_name_info(struct seq_file *m, void *data);
 
@@ -67,6 +59,12 @@ int drm_getmagic(struct drm_device *dev, void *data,
                  struct drm_file *file_priv);
 int drm_authmagic(struct drm_device *dev, void *data,
                   struct drm_file *file_priv);
+int drm_setmaster_ioctl(struct drm_device *dev, void *data,
+                        struct drm_file *file_priv);
+int drm_dropmaster_ioctl(struct drm_device *dev, void *data,
+                         struct drm_file *file_priv);
+int drm_master_open(struct drm_file *file_priv);
+void drm_master_release(struct drm_file *file_priv);
 
 /* drm_sysfs.c */
 extern struct class *drm_class;
@@ -92,13 +90,6 @@ int drm_gem_open_ioctl(struct drm_device *dev, void *data,
 void drm_gem_open(struct drm_device *dev, struct drm_file *file_private);
 void drm_gem_release(struct drm_device *dev, struct drm_file *file_private);
 
-/* drm_drv.c */
-int drm_setmaster_ioctl(struct drm_device *dev, void *data,
-                        struct drm_file *file_priv);
-int drm_dropmaster_ioctl(struct drm_device *dev, void *data,
-                         struct drm_file *file_priv);
-struct drm_master *drm_master_create(struct drm_minor *minor);
-
 /* drm_debugfs.c */
 #if defined(CONFIG_DEBUG_FS)
 int drm_debugfs_init(struct drm_minor *minor, int minor_id,
diff --git a/drivers/gpu/drm/drm_ioctl.c b/drivers/gpu/drm/drm_ioctl.c
index b7a39771c152..1f84ff5f1bf8 100644
--- a/drivers/gpu/drm/drm_ioctl.c
+++ b/drivers/gpu/drm/drm_ioctl.c
@@ -30,6 +30,7 @@
 
 #include <drm/drmP.h>
 #include <drm/drm_core.h>
+#include <drm/drm_auth.h>
 #include "drm_legacy.h"
 #include "drm_internal.h"
 #include "drm_crtc_internal.h"
@@ -37,6 +38,64 @@
 #include <linux/pci.h>
 #include <linux/export.h>
 
+/**
+ * DOC: getunique and setversion story
+ *
+ * BEWARE THE DRAGONS! MIND THE TRAPDOORS!
+ *
+ * In an attempt to warn anyone else who's trying to figure out what's going
+ * on here, I'll try to summarize the story. First things first, let's clear up
+ * the names, because the kernel internals, libdrm and the ioctls are all named
+ * differently:
+ *
+ *  - GET_UNIQUE ioctl, implemented by drm_getunique is wrapped up in libdrm
+ *    through the drmGetBusid function.
+ *  - The libdrm drmSetBusid function is backed by the SET_UNIQUE ioctl. All
+ *    that code is nerved in the kernel with drm_invalid_op().
+ *  - The internal set_busid kernel functions and driver callbacks are
+ *    exclusively use by the SET_VERSION ioctl, because only drm 1.0 (which is
+ *    nerved) allowed userspace to set the busid through the above ioctl.
+ *  - Other ioctls and functions involved are named consistently.
+ *
+ * For anyone wondering what's the difference between drm 1.1 and 1.4: Correctly
+ * handling pci domains in the busid on ppc. Doing this correctly was only
+ * implemented in libdrm in 2010, hence can't be nerved yet. No one knows what's
+ * special with drm 1.2 and 1.3.
+ *
+ * Now the actual horror story of how device lookup in drm works. At large,
+ * there's 2 different ways, either by busid, or by device driver name.
+ *
+ * Opening by busid is fairly simple:
+ *
+ * 1. First call SET_VERSION to make sure pci domains are handled properly. As a
+ *    side-effect this fills out the unique name in the master structure.
+ * 2. Call GET_UNIQUE to read out the unique name from the master structure,
+ *    which matches the busid thanks to step 1. If it doesn't, proceed to try
+ *    the next device node.
+ *
+ * Opening by name is slightly different:
+ *
+ * 1. Directly call VERSION to get the version and to match against the driver
+ *    name returned by that ioctl. Note that SET_VERSION is not called, which
+ *    means the the unique name for the master node just opening is _not_ filled
+ *    out. This despite that with current drm device nodes are always bound to
+ *    one device, and can't be runtime assigned like with drm 1.0.
+ * 2. Match driver name. If it mismatches, proceed to the next device node.
+ * 3. Call GET_UNIQUE, and check whether the unique name has length zero (by
+ *    checking that the first byte in the string is 0). If that's not the case
+ *    libdrm skips and proceeds to the next device node. Probably this is just
+ *    copypasta from drm 1.0 times where a set unique name meant that the driver
+ *    was in use already, but that's just conjecture.
+ *
+ * Long story short: To keep the open by name logic working, GET_UNIQUE must
+ * _not_ return a unique string when SET_VERSION hasn't been called yet,
+ * otherwise libdrm breaks. Even when that unique string can't ever change, and
+ * is totally irrelevant for actually opening the device because runtime
+ * assignable device instances were only support in drm 1.0, which is long dead.
+ * But the libdrm code in drmOpenByName somehow survived, hence this can't be
+ * broken.
+ */
+
 static int drm_version(struct drm_device *dev, void *data,
                        struct drm_file *file_priv);
 
@@ -75,51 +134,6 @@ drm_unset_busid(struct drm_device *dev,
         master->unique_len = 0;
 }
 
-/*
- * Set the bus id.
- *
- * \param inode device inode.
- * \param file_priv DRM file private.
- * \param cmd command.
- * \param arg user argument, pointing to a drm_unique structure.
- * \return zero on success or a negative number on failure.
- *
- * Copies the bus id from userspace into drm_device::unique, and verifies that
- * it matches the device this DRM is attached to (EINVAL otherwise).  Deprecated
- * in interface version 1.1 and will return EBUSY when setversion has requested
- * version 1.1 or greater. Also note that KMS is all version 1.1 and later and
- * UMS was only ever supported on pci devices.
- */
-static int drm_setunique(struct drm_device *dev, void *data,
-                  struct drm_file *file_priv)
-{
-        struct drm_unique *u = data;
-        struct drm_master *master = file_priv->master;
-        int ret;
-
-        if (master->unique_len || master->unique)
-                return -EBUSY;
-
-        if (!u->unique_len || u->unique_len > 1024)
-                return -EINVAL;
-
-        if (drm_core_check_feature(dev, DRIVER_MODESET))
-                return 0;
-
-        if (WARN_ON(!dev->pdev))
-                return -EINVAL;
-
-        ret = drm_pci_set_unique(dev, master, u);
-        if (ret)
-                goto err;
-
-        return 0;
-
-err:
-        drm_unset_busid(dev, master);
-        return ret;
-}
-
 static int drm_set_busid(struct drm_device *dev, struct drm_file *file_priv)
 {
         struct drm_master *master = file_priv->master;
@@ -135,12 +149,7 @@ static int drm_set_busid(struct drm_device *dev, struct drm_file *file_priv)
                         return ret;
                 }
         } else {
-                if (WARN(dev->unique == NULL,
-                         "No drm_driver.set_busid() implementation provided by "
-                         "%ps. Use drm_dev_set_unique() to set the unique "
-                         "name explicitly.", dev->driver))
-                        return -EINVAL;
-
+                WARN_ON(!dev->unique);
                 master->unique = kstrdup(dev->unique, GFP_KERNEL);
                 if (master->unique)
                         master->unique_len = strlen(dev->unique);
@@ -473,7 +482,8 @@ int drm_ioctl_permit(u32 flags, struct drm_file *file_priv)
                 return -EACCES;
 
         /* MASTER is only for master or control clients */
-        if (unlikely((flags & DRM_MASTER) && !file_priv->is_master &&
+        if (unlikely((flags & DRM_MASTER) && 
+                     !drm_is_current_master(file_priv) &&
                      !drm_is_control_client(file_priv)))
                 return -EACCES;
 
@@ -504,7 +514,7 @@ static const struct drm_ioctl_desc drm_ioctls[] = {
         DRM_IOCTL_DEF(DRM_IOCTL_VERSION, drm_version,
                       DRM_UNLOCKED|DRM_RENDER_ALLOW|DRM_CONTROL_ALLOW),
         DRM_IOCTL_DEF(DRM_IOCTL_GET_UNIQUE, drm_getunique, 0),
-        DRM_IOCTL_DEF(DRM_IOCTL_GET_MAGIC, drm_getmagic, 0),
+        DRM_IOCTL_DEF(DRM_IOCTL_GET_MAGIC, drm_getmagic, DRM_UNLOCKED),
         DRM_IOCTL_DEF(DRM_IOCTL_IRQ_BUSID, drm_irq_by_busid, DRM_MASTER|DRM_ROOT_ONLY),
         DRM_IOCTL_DEF(DRM_IOCTL_GET_MAP, drm_legacy_getmap_ioctl, DRM_UNLOCKED),
         DRM_IOCTL_DEF(DRM_IOCTL_GET_CLIENT, drm_getclient, DRM_UNLOCKED),
@@ -513,10 +523,10 @@ static const struct drm_ioctl_desc drm_ioctls[] = {
         DRM_IOCTL_DEF(DRM_IOCTL_SET_CLIENT_CAP, drm_setclientcap, 0),
         DRM_IOCTL_DEF(DRM_IOCTL_SET_VERSION, drm_setversion, DRM_MASTER),
 
-        DRM_IOCTL_DEF(DRM_IOCTL_SET_UNIQUE, drm_setunique, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+        DRM_IOCTL_DEF(DRM_IOCTL_SET_UNIQUE, drm_invalid_op, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
         DRM_IOCTL_DEF(DRM_IOCTL_BLOCK, drm_noop, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
         DRM_IOCTL_DEF(DRM_IOCTL_UNBLOCK, drm_noop, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
-        DRM_IOCTL_DEF(DRM_IOCTL_AUTH_MAGIC, drm_authmagic, DRM_AUTH|DRM_MASTER),
+        DRM_IOCTL_DEF(DRM_IOCTL_AUTH_MAGIC, drm_authmagic, DRM_AUTH|DRM_UNLOCKED|DRM_MASTER),
 
         DRM_IOCTL_DEF(DRM_IOCTL_ADD_MAP, drm_legacy_addmap_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
         DRM_IOCTL_DEF(DRM_IOCTL_RM_MAP, drm_legacy_rmmap_ioctl, DRM_AUTH),
@@ -524,8 +534,8 @@ static const struct drm_ioctl_desc drm_ioctls[] = {
         DRM_IOCTL_DEF(DRM_IOCTL_SET_SAREA_CTX, drm_legacy_setsareactx, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
         DRM_IOCTL_DEF(DRM_IOCTL_GET_SAREA_CTX, drm_legacy_getsareactx, DRM_AUTH),
 
-        DRM_IOCTL_DEF(DRM_IOCTL_SET_MASTER, drm_setmaster_ioctl, DRM_ROOT_ONLY),
-        DRM_IOCTL_DEF(DRM_IOCTL_DROP_MASTER, drm_dropmaster_ioctl, DRM_ROOT_ONLY),
+        DRM_IOCTL_DEF(DRM_IOCTL_SET_MASTER, drm_setmaster_ioctl, DRM_UNLOCKED|DRM_ROOT_ONLY),
+        DRM_IOCTL_DEF(DRM_IOCTL_DROP_MASTER, drm_dropmaster_ioctl, DRM_UNLOCKED|DRM_ROOT_ONLY),
 
         DRM_IOCTL_DEF(DRM_IOCTL_ADD_CTX, drm_legacy_addctx, DRM_AUTH|DRM_ROOT_ONLY),
         DRM_IOCTL_DEF(DRM_IOCTL_RM_CTX, drm_legacy_rmctx, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
diff --git a/drivers/gpu/drm/drm_irq.c b/drivers/gpu/drm/drm_irq.c
index 76e39c50c90c..8ca3d2bf2bda 100644
--- a/drivers/gpu/drm/drm_irq.c
+++ b/drivers/gpu/drm/drm_irq.c
@@ -994,10 +994,10 @@ static void send_vblank_event(struct drm_device *dev,
         e->event.tv_sec = now->tv_sec;
         e->event.tv_usec = now->tv_usec;
 
-        drm_send_event_locked(dev, &e->base);
-
         trace_drm_vblank_event_delivered(e->base.pid, e->pipe,
                                          e->event.sequence);
+
+        drm_send_event_locked(dev, &e->base);
 }
 
 /**
diff --git a/drivers/gpu/drm/drm_legacy.h b/drivers/gpu/drm/drm_legacy.h
index d3b6ee357a2b..c6f422e879dd 100644
--- a/drivers/gpu/drm/drm_legacy.h
+++ b/drivers/gpu/drm/drm_legacy.h
@@ -88,14 +88,10 @@ struct drm_agp_mem {
         struct list_head head;
 };
 
-/*
- * Generic Userspace Locking-API
- */
-
-int drm_legacy_i_have_hw_lock(struct drm_device *d, struct drm_file *f);
+/* drm_lock.c */
 int drm_legacy_lock(struct drm_device *d, void *v, struct drm_file *f);
 int drm_legacy_unlock(struct drm_device *d, void *v, struct drm_file *f);
-int drm_legacy_lock_free(struct drm_lock_data *lock, unsigned int ctx);
+void drm_legacy_lock_release(struct drm_device *dev, struct file *filp);
 
 /* DMA support */
 int drm_legacy_dma_setup(struct drm_device *dev);
diff --git a/drivers/gpu/drm/drm_lock.c b/drivers/gpu/drm/drm_lock.c
index daa2ff12101b..48ac0ebbd663 100644
--- a/drivers/gpu/drm/drm_lock.c
+++ b/drivers/gpu/drm/drm_lock.c
@@ -41,6 +41,110 @@
 static int drm_lock_take(struct drm_lock_data *lock_data, unsigned int context);
 
 /**
+ * Take the heavyweight lock.
+ *
+ * \param lock lock pointer.
+ * \param context locking context.
+ * \return one if the lock is held, or zero otherwise.
+ *
+ * Attempt to mark the lock as held by the given context, via the \p cmpxchg instruction.
+ */
+static
+int drm_lock_take(struct drm_lock_data *lock_data,
+                  unsigned int context)
+{
+        unsigned int old, new, prev;
+        volatile unsigned int *lock = &lock_data->hw_lock->lock;
+
+        spin_lock_bh(&lock_data->spinlock);
+        do {
+                old = *lock;
+                if (old & _DRM_LOCK_HELD)
+                        new = old | _DRM_LOCK_CONT;
+                else {
+                        new = context | _DRM_LOCK_HELD |
+                                ((lock_data->user_waiters + lock_data->kernel_waiters > 1) ?
+                                 _DRM_LOCK_CONT : 0);
+                }
+                prev = cmpxchg(lock, old, new);
+        } while (prev != old);
+        spin_unlock_bh(&lock_data->spinlock);
+
+        if (_DRM_LOCKING_CONTEXT(old) == context) {
+                if (old & _DRM_LOCK_HELD) {
+                        if (context != DRM_KERNEL_CONTEXT) {
+                                DRM_ERROR("%d holds heavyweight lock\n",
+                                          context);
+                        }
+                        return 0;
+                }
+        }
+
+        if ((_DRM_LOCKING_CONTEXT(new)) == context && (new & _DRM_LOCK_HELD)) {
+                /* Have lock */
+                return 1;
+        }
+        return 0;
+}
+
+/**
+ * This takes a lock forcibly and hands it to context.  Should ONLY be used
+ * inside *_unlock to give lock to kernel before calling *_dma_schedule.
+ *
+ * \param dev DRM device.
+ * \param lock lock pointer.
+ * \param context locking context.
+ * \return always one.
+ *
+ * Resets the lock file pointer.
+ * Marks the lock as held by the given context, via the \p cmpxchg instruction.
+ */
+static int drm_lock_transfer(struct drm_lock_data *lock_data,
+                             unsigned int context)
+{
+        unsigned int old, new, prev;
+        volatile unsigned int *lock = &lock_data->hw_lock->lock;
+
+        lock_data->file_priv = NULL;
+        do {
+                old = *lock;
+                new = context | _DRM_LOCK_HELD;
+                prev = cmpxchg(lock, old, new);
+        } while (prev != old);
+        return 1;
+}
+
+static int drm_legacy_lock_free(struct drm_lock_data *lock_data,
+                                unsigned int context)
+{
+        unsigned int old, new, prev;
+        volatile unsigned int *lock = &lock_data->hw_lock->lock;
+
+        spin_lock_bh(&lock_data->spinlock);
+        if (lock_data->kernel_waiters != 0) {
+                drm_lock_transfer(lock_data, 0);
+                lock_data->idle_has_lock = 1;
+                spin_unlock_bh(&lock_data->spinlock);
+                return 1;
+        }
+        spin_unlock_bh(&lock_data->spinlock);
+
+        do {
+                old = *lock;
+                new = _DRM_LOCKING_CONTEXT(old);
+                prev = cmpxchg(lock, old, new);
+        } while (prev != old);
+
+        if (_DRM_LOCK_IS_HELD(old) && _DRM_LOCKING_CONTEXT(old) != context) {
+                DRM_ERROR("%d freed heavyweight lock held by %d\n",
+                          context, _DRM_LOCKING_CONTEXT(old));
+                return 1;
+        }
+        wake_up_interruptible(&lock_data->lock_queue);
+        return 0;
+}
+
+/**
  * Lock ioctl.
  *
  * \param inode device inode.
@@ -115,7 +219,7 @@ int drm_legacy_lock(struct drm_device *dev, void *data,
         /* don't set the block all signals on the master process for now 
          * really probably not the correct answer but lets us debug xkb
          * xserver for now */
-        if (!file_priv->is_master) {
+        if (!drm_is_current_master(file_priv)) {
                 dev->sigdata.context = lock->context;
                 dev->sigdata.lock = master->lock.hw_lock;
         }
@@ -165,120 +269,6 @@ int drm_legacy_unlock(struct drm_device *dev, void *data, struct drm_file *file_
 }
 
 /**
- * Take the heavyweight lock.
- *
- * \param lock lock pointer.
- * \param context locking context.
- * \return one if the lock is held, or zero otherwise.
- *
- * Attempt to mark the lock as held by the given context, via the \p cmpxchg instruction.
- */
-static
-int drm_lock_take(struct drm_lock_data *lock_data,
-                  unsigned int context)
-{
-        unsigned int old, new, prev;
-        volatile unsigned int *lock = &lock_data->hw_lock->lock;
-
-        spin_lock_bh(&lock_data->spinlock);
-        do {
-                old = *lock;
-                if (old & _DRM_LOCK_HELD)
-                        new = old | _DRM_LOCK_CONT;
-                else {
-                        new = context | _DRM_LOCK_HELD |
-                                ((lock_data->user_waiters + lock_data->kernel_waiters > 1) ?
-                                 _DRM_LOCK_CONT : 0);
-                }
-                prev = cmpxchg(lock, old, new);
-        } while (prev != old);
-        spin_unlock_bh(&lock_data->spinlock);
-
-        if (_DRM_LOCKING_CONTEXT(old) == context) {
-                if (old & _DRM_LOCK_HELD) {
-                        if (context != DRM_KERNEL_CONTEXT) {
-                                DRM_ERROR("%d holds heavyweight lock\n",
-                                          context);
-                        }
-                        return 0;
-                }
-        }
-
-        if ((_DRM_LOCKING_CONTEXT(new)) == context && (new & _DRM_LOCK_HELD)) {
-                /* Have lock */
-                return 1;
-        }
-        return 0;
-}
-
-/**
- * This takes a lock forcibly and hands it to context.  Should ONLY be used
- * inside *_unlock to give lock to kernel before calling *_dma_schedule.
- *
- * \param dev DRM device.
- * \param lock lock pointer.
- * \param context locking context.
- * \return always one.
- *
- * Resets the lock file pointer.
- * Marks the lock as held by the given context, via the \p cmpxchg instruction.
- */
-static int drm_lock_transfer(struct drm_lock_data *lock_data,
-                             unsigned int context)
-{
-        unsigned int old, new, prev;
-        volatile unsigned int *lock = &lock_data->hw_lock->lock;
-
-        lock_data->file_priv = NULL;
-        do {
-                old = *lock;
-                new = context | _DRM_LOCK_HELD;
-                prev = cmpxchg(lock, old, new);
-        } while (prev != old);
-        return 1;
-}
-
-/**
- * Free lock.
- *
- * \param dev DRM device.
- * \param lock lock.
- * \param context context.
- *
- * Resets the lock file pointer.
- * Marks the lock as not held, via the \p cmpxchg instruction. Wakes any task
- * waiting on the lock queue.
- */
-int drm_legacy_lock_free(struct drm_lock_data *lock_data, unsigned int context)
-{
-        unsigned int old, new, prev;
-        volatile unsigned int *lock = &lock_data->hw_lock->lock;
-
-        spin_lock_bh(&lock_data->spinlock);
-        if (lock_data->kernel_waiters != 0) {
-                drm_lock_transfer(lock_data, 0);
-                lock_data->idle_has_lock = 1;
-                spin_unlock_bh(&lock_data->spinlock);
-                return 1;
-        }
-        spin_unlock_bh(&lock_data->spinlock);
-
-        do {
-                old = *lock;
-                new = _DRM_LOCKING_CONTEXT(old);
-                prev = cmpxchg(lock, old, new);
-        } while (prev != old);
-
-        if (_DRM_LOCK_IS_HELD(old) && _DRM_LOCKING_CONTEXT(old) != context) {
-                DRM_ERROR("%d freed heavyweight lock held by %d\n",
-                          context, _DRM_LOCKING_CONTEXT(old));
-                return 1;
-        }
-        wake_up_interruptible(&lock_data->lock_queue);
-        return 0;
-}
-
-/**
  * This function returns immediately and takes the hw lock
  * with the kernel context if it is free, otherwise it gets the highest priority when and if
  * it is eventually released.
@@ -330,11 +320,27 @@ void drm_legacy_idlelock_release(struct drm_lock_data *lock_data)
 }
 EXPORT_SYMBOL(drm_legacy_idlelock_release);
 
-int drm_legacy_i_have_hw_lock(struct drm_device *dev,
-                              struct drm_file *file_priv)
+static int drm_legacy_i_have_hw_lock(struct drm_device *dev,
+                                     struct drm_file *file_priv)
 {
         struct drm_master *master = file_priv->master;
         return (file_priv->lock_count && master->lock.hw_lock &&
                 _DRM_LOCK_IS_HELD(master->lock.hw_lock->lock) &&
                 master->lock.file_priv == file_priv);
 }
+
+void drm_legacy_lock_release(struct drm_device *dev, struct file *filp)
+{
+        struct drm_file *file_priv = filp->private_data;
+
+        /* if the master has gone away we can't do anything with the lock */
+        if (!dev->master)
+                return;
+
+        if (drm_legacy_i_have_hw_lock(dev, file_priv)) {
+                DRM_DEBUG("File %p released, freeing lock for context %d\n",
+                          filp, _DRM_LOCKING_CONTEXT(file_priv->master->lock.hw_lock->lock));
+                drm_legacy_lock_free(&file_priv->master->lock,
+                                     _DRM_LOCKING_CONTEXT(file_priv->master->lock.hw_lock->lock));
+        }
+}
diff --git a/drivers/gpu/drm/drm_pci.c b/drivers/gpu/drm/drm_pci.c
index 29d5a548d07a..b2f8f1062d5f 100644
--- a/drivers/gpu/drm/drm_pci.c
+++ b/drivers/gpu/drm/drm_pci.c
@@ -144,50 +144,6 @@ int drm_pci_set_busid(struct drm_device *dev, struct drm_master *master)
 }
 EXPORT_SYMBOL(drm_pci_set_busid);
 
-int drm_pci_set_unique(struct drm_device *dev,
-                       struct drm_master *master,
-                       struct drm_unique *u)
-{
-        int domain, bus, slot, func, ret;
-
-        master->unique_len = u->unique_len;
-        master->unique = kmalloc(master->unique_len + 1, GFP_KERNEL);
-        if (!master->unique) {
-                ret = -ENOMEM;
-                goto err;
-        }
-
-        if (copy_from_user(master->unique, u->unique, master->unique_len)) {
-                ret = -EFAULT;
-                goto err;
-        }
-
-        master->unique[master->unique_len] = '\0';
-
-        /* Return error if the busid submitted doesn't match the device's actual
-         * busid.
-         */
-        ret = sscanf(master->unique, "PCI:%d:%d:%d", &bus, &slot, &func);
-        if (ret != 3) {
-                ret = -EINVAL;
-                goto err;
-        }
-
-        domain = bus >> 8;
-        bus &= 0xff;
-
-        if ((domain != drm_get_pci_domain(dev)) ||
-            (bus != dev->pdev->bus->number) ||
-            (slot != PCI_SLOT(dev->pdev->devfn)) ||
-            (func != PCI_FUNC(dev->pdev->devfn))) {
-                ret = -EINVAL;
-                goto err;
-        }
-        return 0;
-err:
-        return ret;
-}
-
 static int drm_pci_irq_by_busid(struct drm_device *dev, struct drm_irq_busid *p)
 {
         if ((p->busnum >> 8) != drm_get_pci_domain(dev) ||
@@ -444,13 +400,6 @@ int drm_irq_by_busid(struct drm_device *dev, void *data,
 {
         return -EINVAL;
 }
-
-int drm_pci_set_unique(struct drm_device *dev,
-                       struct drm_master *master,
-                       struct drm_unique *u)
-{
-        return -EINVAL;
-}
 #endif
 
 EXPORT_SYMBOL(drm_pci_init);
diff --git a/drivers/gpu/drm/drm_plane_helper.c b/drivers/gpu/drm/drm_plane_helper.c
index fc51306fe365..16c4a7bd7465 100644
--- a/drivers/gpu/drm/drm_plane_helper.c
+++ b/drivers/gpu/drm/drm_plane_helper.c
@@ -115,6 +115,7 @@ static int get_connectors_for_crtc(struct drm_crtc *crtc,
  * @src: source coordinates in 16.16 fixed point
  * @dest: integer destination coordinates
  * @clip: integer clipping coordinates
+ * @rotation: plane rotation
  * @min_scale: minimum @src:@dest scaling factor in 16.16 fixed point
  * @max_scale: maximum @src:@dest scaling factor in 16.16 fixed point
  * @can_position: is it legal to position the plane such that it
@@ -134,16 +135,17 @@ static int get_connectors_for_crtc(struct drm_crtc *crtc,
  * Zero if update appears valid, error code on failure
  */
 int drm_plane_helper_check_update(struct drm_plane *plane,
-                                    struct drm_crtc *crtc,
-                                    struct drm_framebuffer *fb,
-                                    struct drm_rect *src,
-                                    struct drm_rect *dest,
-                                    const struct drm_rect *clip,
-                                    int min_scale,
-                                    int max_scale,
-                                    bool can_position,
-                                    bool can_update_disabled,
-                                    bool *visible)
+                                  struct drm_crtc *crtc,
+                                  struct drm_framebuffer *fb,
+                                  struct drm_rect *src,
+                                  struct drm_rect *dest,
+                                  const struct drm_rect *clip,
+                                  unsigned int rotation,
+                                  int min_scale,
+                                  int max_scale,
+                                  bool can_position,
+                                  bool can_update_disabled,
+                                  bool *visible)
 {
         int hscale, vscale;
 
@@ -163,6 +165,8 @@ int drm_plane_helper_check_update(struct drm_plane *plane,
                 return -EINVAL;
         }
 
+        drm_rect_rotate(src, fb->width << 16, fb->height << 16, rotation);
+
         /* Check scaling */
         hscale = drm_rect_calc_hscale(src, dest, min_scale, max_scale);
         vscale = drm_rect_calc_vscale(src, dest, min_scale, max_scale);
@@ -174,6 +178,9 @@ int drm_plane_helper_check_update(struct drm_plane *plane,
         }
 
         *visible = drm_rect_clip_scaled(src, dest, clip, hscale, vscale);
+
+        drm_rect_rotate_inv(src, fb->width << 16, fb->height << 16, rotation);
+
         if (!*visible)
                 /*
                  * Plane isn't visible; some drivers can handle this
@@ -267,6 +274,7 @@ int drm_primary_helper_update(struct drm_plane *plane, struct drm_crtc *crtc,
 
         ret = drm_plane_helper_check_update(plane, crtc, fb,
                                             &src, &dest, &clip,
+                                            BIT(DRM_ROTATE_0),
                                             DRM_PLANE_HELPER_NO_SCALING,
                                             DRM_PLANE_HELPER_NO_SCALING,
                                             false, false, &visible);
diff --git a/drivers/gpu/drm/drm_platform.c b/drivers/gpu/drm/drm_platform.c
index 644169e1a029..2c819ef90090 100644
--- a/drivers/gpu/drm/drm_platform.c
+++ b/drivers/gpu/drm/drm_platform.c
@@ -68,24 +68,6 @@ err_free:
         return ret;
 }
 
-int drm_platform_set_busid(struct drm_device *dev, struct drm_master *master)
-{
-        int id;
-
-        id = dev->platformdev->id;
-        if (id < 0)
-                id = 0;
-
-        master->unique = kasprintf(GFP_KERNEL, "platform:%s:%02d",
-                                                dev->platformdev->name, id);
-        if (!master->unique)
-                return -ENOMEM;
-
-        master->unique_len = strlen(master->unique);
-        return 0;
-}
-EXPORT_SYMBOL(drm_platform_set_busid);
-
 /**
  * drm_platform_init - Register a platform device with the DRM subsystem
  * @driver: DRM device driver
diff --git a/drivers/gpu/drm/drm_simple_kms_helper.c b/drivers/gpu/drm/drm_simple_kms_helper.c
index b2071d495ada..0db36d27e90b 100644
--- a/drivers/gpu/drm/drm_simple_kms_helper.c
+++ b/drivers/gpu/drm/drm_simple_kms_helper.c
@@ -105,6 +105,7 @@ static int drm_simple_kms_plane_atomic_check(struct drm_plane *plane,
         ret = drm_plane_helper_check_update(plane, &pipe->crtc,
                                             plane_state->fb,
                                             &src, &dest, &clip,
+                                            plane_state->rotation,
                                             DRM_PLANE_HELPER_NO_SCALING,
                                             DRM_PLANE_HELPER_NO_SCALING,
                                             false, true, &visible);
diff --git a/drivers/gpu/drm/drm_vm.c b/drivers/gpu/drm/drm_vm.c
index ac9f4b3ec615..43ff44a2b8e7 100644
--- a/drivers/gpu/drm/drm_vm.c
+++ b/drivers/gpu/drm/drm_vm.c
@@ -670,57 +670,3 @@ void drm_legacy_vma_flush(struct drm_device *dev)
                 kfree(vma);
         }
 }
-
-int drm_vma_info(struct seq_file *m, void *data)
-{
-        struct drm_info_node *node = (struct drm_info_node *) m->private;
-        struct drm_device *dev = node->minor->dev;
-        struct drm_vma_entry *pt;
-        struct vm_area_struct *vma;
-        unsigned long vma_count = 0;
-#if defined(__i386__)
-        unsigned int pgprot;
-#endif
-
-        mutex_lock(&dev->struct_mutex);
-        list_for_each_entry(pt, &dev->vmalist, head)
-                vma_count++;
-
-        seq_printf(m, "vma use count: %lu, high_memory = %pK, 0x%pK\n",
-                   vma_count, high_memory,
-                   (void *)(unsigned long)virt_to_phys(high_memory));
-
-        list_for_each_entry(pt, &dev->vmalist, head) {
-                vma = pt->vma;
-                if (!vma)
-                        continue;
-                seq_printf(m,
-                           "\n%5d 0x%pK-0x%pK %c%c%c%c%c%c 0x%08lx000",
-                           pt->pid,
-                           (void *)vma->vm_start, (void *)vma->vm_end,
-                           vma->vm_flags & VM_READ ? 'r' : '-',
-                           vma->vm_flags & VM_WRITE ? 'w' : '-',
-                           vma->vm_flags & VM_EXEC ? 'x' : '-',
-                           vma->vm_flags & VM_MAYSHARE ? 's' : 'p',
-                           vma->vm_flags & VM_LOCKED ? 'l' : '-',
-                           vma->vm_flags & VM_IO ? 'i' : '-',
-                           vma->vm_pgoff);
-
-#if defined(__i386__)
-                pgprot = pgprot_val(vma->vm_page_prot);
-                seq_printf(m, " %c%c%c%c%c%c%c%c%c",
-                           pgprot & _PAGE_PRESENT ? 'p' : '-',
-                           pgprot & _PAGE_RW ? 'w' : 'r',
-                           pgprot & _PAGE_USER ? 'u' : 's',
-                           pgprot & _PAGE_PWT ? 't' : 'b',
-                           pgprot & _PAGE_PCD ? 'u' : 'c',
-                           pgprot & _PAGE_ACCESSED ? 'a' : '-',
-                           pgprot & _PAGE_DIRTY ? 'd' : '-',
-                           pgprot & _PAGE_PSE ? 'm' : 'k',
-                           pgprot & _PAGE_GLOBAL ? 'g' : 'l');
-#endif
-                seq_printf(m, "\n");
-        }
-        mutex_unlock(&dev->struct_mutex);
-        return 0;
-}
diff --git a/drivers/gpu/drm/etnaviv/etnaviv_drv.c b/drivers/gpu/drm/etnaviv/etnaviv_drv.c
index 3d4f56df8359..340d390306d8 100644
--- a/drivers/gpu/drm/etnaviv/etnaviv_drv.c
+++ b/drivers/gpu/drm/etnaviv/etnaviv_drv.c
@@ -496,7 +496,6 @@ static struct drm_driver etnaviv_drm_driver = {
                                 DRIVER_RENDER,
         .open               = etnaviv_open,
         .preclose           = etnaviv_preclose,
-        .set_busid          = drm_platform_set_busid,
         .gem_free_object_unlocked = etnaviv_gem_free_object,
         .gem_vm_ops         = &vm_ops,
         .prime_handle_to_fd = drm_gem_prime_handle_to_fd,
diff --git a/drivers/gpu/drm/exynos/exynos_drm_drv.c b/drivers/gpu/drm/exynos/exynos_drm_drv.c
index 4a679fb9bb02..13d28d4229e2 100644
--- a/drivers/gpu/drm/exynos/exynos_drm_drv.c
+++ b/drivers/gpu/drm/exynos/exynos_drm_drv.c
@@ -407,7 +407,6 @@ static struct drm_driver exynos_drm_driver = {
         .preclose               = exynos_drm_preclose,
         .lastclose              = exynos_drm_lastclose,
         .postclose              = exynos_drm_postclose,
-        .set_busid              = drm_platform_set_busid,
         .get_vblank_counter     = drm_vblank_no_hw_counter,
         .enable_vblank          = exynos_drm_crtc_enable_vblank,
         .disable_vblank         = exynos_drm_crtc_disable_vblank,
diff --git a/drivers/gpu/drm/fsl-dcu/fsl_dcu_drm_kms.c b/drivers/gpu/drm/fsl-dcu/fsl_dcu_drm_kms.c
index c564ec612b59..a6e4cd591960 100644
--- a/drivers/gpu/drm/fsl-dcu/fsl_dcu_drm_kms.c
+++ b/drivers/gpu/drm/fsl-dcu/fsl_dcu_drm_kms.c
@@ -37,23 +37,22 @@ int fsl_dcu_drm_modeset_init(struct fsl_dcu_drm_device *fsl_dev)
 
         ret = fsl_dcu_drm_crtc_create(fsl_dev);
         if (ret)
-                return ret;
+                goto err;
 
         ret = fsl_dcu_drm_encoder_create(fsl_dev, &fsl_dev->crtc);
         if (ret)
-                goto fail_encoder;
+                goto err;
 
         ret = fsl_dcu_drm_connector_create(fsl_dev, &fsl_dev->encoder);
         if (ret)
-                goto fail_connector;
+                goto err;
 
         drm_mode_config_reset(fsl_dev->drm);
         drm_kms_helper_poll_init(fsl_dev->drm);
 
         return 0;
-fail_encoder:
-        fsl_dev->crtc.funcs->destroy(&fsl_dev->crtc);
-fail_connector:
-        fsl_dev->encoder.funcs->destroy(&fsl_dev->encoder);
+
+err:
+        drm_mode_config_cleanup(fsl_dev->drm);
         return ret;
 }
diff --git a/drivers/gpu/drm/hisilicon/kirin/kirin_drm_drv.c b/drivers/gpu/drm/hisilicon/kirin/kirin_drm_drv.c
index 193657259ee9..1edd9bc80294 100644
--- a/drivers/gpu/drm/hisilicon/kirin/kirin_drm_drv.c
+++ b/drivers/gpu/drm/hisilicon/kirin/kirin_drm_drv.c
@@ -171,7 +171,6 @@ static struct drm_driver kirin_drm_driver = {
         .driver_features        = DRIVER_GEM | DRIVER_MODESET | DRIVER_PRIME |
                                   DRIVER_ATOMIC | DRIVER_HAVE_IRQ,
         .fops                   = &kirin_drm_fops,
-        .set_busid              = drm_platform_set_busid,
 
         .gem_free_object_unlocked = drm_gem_cma_free_object,
         .gem_vm_ops             = &drm_gem_cma_vm_ops,
@@ -221,19 +220,12 @@ static int kirin_drm_bind(struct device *dev)
         if (ret)
                 goto err_kms_cleanup;
 
-        /* connectors should be registered after drm device register */
-        ret = drm_connector_register_all(drm_dev);
-        if (ret)
-                goto err_drm_dev_unregister;
-
         DRM_INFO("Initialized %s %d.%d.%d %s on minor %d\n",
                  driver->name, driver->major, driver->minor, driver->patchlevel,
                  driver->date, drm_dev->primary->index);
 
         return 0;
 
-err_drm_dev_unregister:
-        drm_dev_unregister(drm_dev);
 err_kms_cleanup:
         kirin_drm_kms_cleanup(drm_dev);
 err_drm_dev_unref:
@@ -246,7 +238,6 @@ static void kirin_drm_unbind(struct device *dev)
 {
         struct drm_device *drm_dev = dev_get_drvdata(dev);
 
-        drm_connector_unregister_all(drm_dev);
         drm_dev_unregister(drm_dev);
         kirin_drm_kms_cleanup(drm_dev);
         drm_dev_unref(drm_dev);
diff --git a/drivers/gpu/drm/i915/i915_drv.h b/drivers/gpu/drm/i915/i915_drv.h
index 0113207967d9..ee338655f782 100644
--- a/drivers/gpu/drm/i915/i915_drv.h
+++ b/drivers/gpu/drm/i915/i915_drv.h
@@ -47,6 +47,7 @@
 #include <drm/intel-gtt.h>
 #include <drm/drm_legacy.h> /* for struct drm_dma_handle */
 #include <drm/drm_gem.h>
+#include <drm/drm_auth.h>
 
 #include "i915_params.h"
 #include "i915_reg.h"
@@ -3673,7 +3674,7 @@ extern void intel_modeset_init_hw(struct drm_device *dev);
 extern void intel_modeset_init(struct drm_device *dev);
 extern void intel_modeset_gem_init(struct drm_device *dev);
 extern void intel_modeset_cleanup(struct drm_device *dev);
-extern void intel_connector_unregister(struct intel_connector *);
+extern void intel_connector_unregister(struct drm_connector *);
 extern int intel_modeset_vga_set_state(struct drm_device *dev, bool state);
 extern void intel_display_resume(struct drm_device *dev);
 extern void i915_redisable_vga(struct drm_device *dev);
diff --git a/drivers/gpu/drm/i915/i915_gem_execbuffer.c b/drivers/gpu/drm/i915/i915_gem_execbuffer.c
index 8097698b9622..7941f1fe9cd2 100644
--- a/drivers/gpu/drm/i915/i915_gem_execbuffer.c
+++ b/drivers/gpu/drm/i915/i915_gem_execbuffer.c
@@ -1446,7 +1446,7 @@ i915_gem_do_execbuffer(struct drm_device *dev, void *data,
 
         dispatch_flags = 0;
         if (args->flags & I915_EXEC_SECURE) {
-                if (!file->is_master || !capable(CAP_SYS_ADMIN))
+                if (!drm_is_current_master(file) || !capable(CAP_SYS_ADMIN))
                     return -EPERM;
 
                 dispatch_flags |= I915_DISPATCH_SECURE;
@@ -1553,7 +1553,7 @@ i915_gem_do_execbuffer(struct drm_device *dev, void *data,
                                                              batch_obj,
                                                              args->batch_start_offset,
                                                              args->batch_len,
-                                                             file->is_master);
+                                                             drm_is_current_master(file));
                 if (IS_ERR(parsed_batch_obj)) {
                         ret = PTR_ERR(parsed_batch_obj);
                         goto err;
diff --git a/drivers/gpu/drm/i915/intel_crt.c b/drivers/gpu/drm/i915/intel_crt.c
index 9465de4135aa..e115bcc6766f 100644
--- a/drivers/gpu/drm/i915/intel_crt.c
+++ b/drivers/gpu/drm/i915/intel_crt.c
@@ -743,6 +743,7 @@ static const struct drm_connector_funcs intel_crt_connector_funcs = {
         .dpms = drm_atomic_helper_connector_dpms,
         .detect = intel_crt_detect,
         .fill_modes = drm_helper_probe_single_connector_modes,
+        .early_unregister = intel_connector_unregister,
         .destroy = intel_crt_destroy,
         .set_property = intel_crt_set_property,
         .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
@@ -875,7 +876,6 @@ void intel_crt_init(struct drm_device *dev)
                 crt->base.get_hw_state = intel_crt_get_hw_state;
         }
         intel_connector->get_hw_state = intel_connector_get_hw_state;
-        intel_connector->unregister = intel_connector_unregister;
 
         drm_connector_helper_add(connector, &intel_crt_connector_helper_funcs);
 
diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c
index 49322f6cfa2b..b12085a8bfa6 100644
--- a/drivers/gpu/drm/i915/intel_display.c
+++ b/drivers/gpu/drm/i915/intel_display.c
@@ -14102,6 +14102,7 @@ intel_check_primary_plane(struct drm_plane *plane,
 
         return drm_plane_helper_check_update(plane, crtc, fb, &state->src,
                                              &state->dst, &state->clip,
+                                             state->base.rotation,
                                              min_scale, max_scale,
                                              can_position, true,
                                              &state->visible);
@@ -14293,6 +14294,7 @@ intel_check_cursor_plane(struct drm_plane *plane,
 
         ret = drm_plane_helper_check_update(plane, crtc, fb, &state->src,
                                             &state->dst, &state->clip,
+                                            state->base.rotation,
                                             DRM_PLANE_HELPER_NO_SCALING,
                                             DRM_PLANE_HELPER_NO_SCALING,
                                             true, true, &state->visible);
@@ -16217,23 +16219,20 @@ void intel_modeset_gem_init(struct drm_device *dev)
         intel_backlight_register(dev);
 }
 
-void intel_connector_unregister(struct intel_connector *intel_connector)
+void intel_connector_unregister(struct drm_connector *connector)
 {
-        struct drm_connector *connector = &intel_connector->base;
+        struct intel_connector *intel_connector = to_intel_connector(connector);
 
+        intel_backlight_device_unregister(intel_connector);
         intel_panel_destroy_backlight(connector);
-        drm_connector_unregister(connector);
 }
 
 void intel_modeset_cleanup(struct drm_device *dev)
 {
         struct drm_i915_private *dev_priv = dev->dev_private;
-        struct intel_connector *connector;
 
         intel_disable_gt_powersave(dev_priv);
 
-        intel_backlight_unregister(dev);
-
         /*
          * Interrupts and polling as the first thing to avoid creating havoc.
          * Too much stuff here (turning of connectors, ...) would
@@ -16254,9 +16253,7 @@ void intel_modeset_cleanup(struct drm_device *dev)
         /* flush any delayed tasks or pending work */
         flush_scheduled_work();
 
-        /* destroy the backlight and sysfs files before encoders/connectors */
-        for_each_intel_connector(dev, connector)
-                connector->unregister(connector);
+        drm_connector_unregister_all(dev);
 
         drm_mode_config_cleanup(dev);
 
diff --git a/drivers/gpu/drm/i915/intel_dp.c b/drivers/gpu/drm/i915/intel_dp.c
index be083519dac9..0b84f8e5df50 100644
--- a/drivers/gpu/drm/i915/intel_dp.c
+++ b/drivers/gpu/drm/i915/intel_dp.c
@@ -1177,7 +1177,6 @@ static void intel_aux_reg_init(struct intel_dp *intel_dp)
 static void
 intel_dp_aux_fini(struct intel_dp *intel_dp)
 {
-        drm_dp_aux_unregister(&intel_dp->aux);
         kfree(intel_dp->aux.name);
 }
 
@@ -1212,15 +1211,6 @@ intel_dp_aux_init(struct intel_dp *intel_dp, struct intel_connector *connector)
         return 0;
 }
 
-static void
-intel_dp_connector_unregister(struct intel_connector *intel_connector)
-{
-        struct intel_dp *intel_dp = intel_attached_dp(&intel_connector->base);
-
-        intel_dp_aux_fini(intel_dp);
-        intel_connector_unregister(intel_connector);
-}
-
 static int
 intel_dp_sink_rates(struct intel_dp *intel_dp, const int **sink_rates)
 {
@@ -4457,6 +4447,13 @@ done:
 }
 
 static void
+intel_dp_connector_unregister(struct drm_connector *connector)
+{
+        drm_dp_aux_unregister(&intel_attached_dp(connector)->aux);
+        intel_connector_unregister(connector);
+}
+
+static void
 intel_dp_connector_destroy(struct drm_connector *connector)
 {
         struct intel_connector *intel_connector = to_intel_connector(connector);
@@ -4496,6 +4493,9 @@ void intel_dp_encoder_destroy(struct drm_encoder *encoder)
                         intel_dp->edp_notifier.notifier_call = NULL;
                 }
         }
+
+        intel_dp_aux_fini(intel_dp);
+
         drm_encoder_cleanup(encoder);
         kfree(intel_dig_port);
 }
@@ -4572,6 +4572,7 @@ static const struct drm_connector_funcs intel_dp_connector_funcs = {
         .fill_modes = drm_helper_probe_single_connector_modes,
         .set_property = intel_dp_set_property,
         .atomic_get_property = intel_connector_atomic_get_property,
+        .early_unregister = intel_dp_connector_unregister,
         .destroy = intel_dp_connector_destroy,
         .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
         .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
@@ -5487,7 +5488,6 @@ intel_dp_init_connector(struct intel_digital_port *intel_dig_port,
                 intel_connector->get_hw_state = intel_ddi_connector_get_hw_state;
         else
                 intel_connector->get_hw_state = intel_connector_get_hw_state;
-        intel_connector->unregister = intel_dp_connector_unregister;
 
         /* Set up the hotplug pin. */
         switch (port) {
diff --git a/drivers/gpu/drm/i915/intel_dp_mst.c b/drivers/gpu/drm/i915/intel_dp_mst.c
index f62ca9a126b3..9646816604be 100644
--- a/drivers/gpu/drm/i915/intel_dp_mst.c
+++ b/drivers/gpu/drm/i915/intel_dp_mst.c
@@ -336,6 +336,7 @@ static const struct drm_connector_funcs intel_dp_mst_connector_funcs = {
         .fill_modes = drm_helper_probe_single_connector_modes,
         .set_property = intel_dp_mst_set_property,
         .atomic_get_property = intel_connector_atomic_get_property,
+        .early_unregister = intel_connector_unregister,
         .destroy = intel_dp_mst_connector_destroy,
         .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
         .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
@@ -455,7 +456,6 @@ static struct drm_connector *intel_dp_add_mst_connector(struct drm_dp_mst_topolo
         drm_connector_init(dev, connector, &intel_dp_mst_connector_funcs, DRM_MODE_CONNECTOR_DisplayPort);
         drm_connector_helper_add(connector, &intel_dp_mst_connector_helper_funcs);
 
-        intel_connector->unregister = intel_connector_unregister;
         intel_connector->get_hw_state = intel_dp_mst_get_hw_state;
         intel_connector->mst_port = intel_dp;
         intel_connector->port = port;
@@ -489,7 +489,7 @@ static void intel_dp_destroy_mst_connector(struct drm_dp_mst_topology_mgr *mgr,
         struct intel_connector *intel_connector = to_intel_connector(connector);
         struct drm_device *dev = connector->dev;
 
-        intel_connector->unregister(intel_connector);
+        drm_connector_unregister(connector);
 
         /* need to nuke the connector */
         drm_modeset_lock_all(dev);
diff --git a/drivers/gpu/drm/i915/intel_drv.h b/drivers/gpu/drm/i915/intel_drv.h
index 270da8de0acf..65e60ff3b553 100644
--- a/drivers/gpu/drm/i915/intel_drv.h
+++ b/drivers/gpu/drm/i915/intel_drv.h
@@ -242,14 +242,6 @@ struct intel_connector {
          * and active (i.e. dpms ON state). */
         bool (*get_hw_state)(struct intel_connector *);
 
-        /*
-         * Removes all interfaces through which the connector is accessible
-         * - like sysfs, debugfs entries -, so that no new operations can be
-         * started on the connector. Also makes sure all currently pending
-         * operations finish before returing.
-         */
-        void (*unregister)(struct intel_connector *);
-
         /* Panel info for eDP and LVDS */
         struct intel_panel panel;
 
@@ -1496,7 +1488,14 @@ extern struct drm_display_mode *intel_find_panel_downclock(
                                 struct drm_display_mode *fixed_mode,
                                 struct drm_connector *connector);
 void intel_backlight_register(struct drm_device *dev);
-void intel_backlight_unregister(struct drm_device *dev);
+
+#if IS_ENABLED(CONFIG_BACKLIGHT_CLASS_DEVICE)
+void intel_backlight_device_unregister(struct intel_connector *connector);
+#else /* CONFIG_BACKLIGHT_CLASS_DEVICE */
+static inline void intel_backlight_device_unregister(struct intel_connector *connector)
+{
+}
+#endif /* CONFIG_BACKLIGHT_CLASS_DEVICE */
 
 
 /* intel_psr.c */
diff --git a/drivers/gpu/drm/i915/intel_dsi.c b/drivers/gpu/drm/i915/intel_dsi.c
index a2ead5eac336..e9eda691e8be 100644
--- a/drivers/gpu/drm/i915/intel_dsi.c
+++ b/drivers/gpu/drm/i915/intel_dsi.c
@@ -1384,6 +1384,7 @@ static const struct drm_connector_helper_funcs intel_dsi_connector_helper_funcs
 static const struct drm_connector_funcs intel_dsi_connector_funcs = {
         .dpms = drm_atomic_helper_connector_dpms,
         .detect = intel_dsi_detect,
+        .early_unregister = intel_connector_unregister,
         .destroy = intel_dsi_connector_destroy,
         .fill_modes = drm_helper_probe_single_connector_modes,
         .set_property = intel_dsi_set_property,
@@ -1460,7 +1461,6 @@ void intel_dsi_init(struct drm_device *dev)
         intel_encoder->get_config = intel_dsi_get_config;
 
         intel_connector->get_hw_state = intel_connector_get_hw_state;
-        intel_connector->unregister = intel_connector_unregister;
 
         /*
          * On BYT/CHV, pipe A maps to MIPI DSI port A, pipe B maps to MIPI DSI
diff --git a/drivers/gpu/drm/i915/intel_dvo.c b/drivers/gpu/drm/i915/intel_dvo.c
index c86f88ed92fd..60e4ddf2ec6d 100644
--- a/drivers/gpu/drm/i915/intel_dvo.c
+++ b/drivers/gpu/drm/i915/intel_dvo.c
@@ -341,6 +341,7 @@ static void intel_dvo_destroy(struct drm_connector *connector)
 static const struct drm_connector_funcs intel_dvo_connector_funcs = {
         .dpms = drm_atomic_helper_connector_dpms,
         .detect = intel_dvo_detect,
+        .early_unregister = intel_connector_unregister,
         .destroy = intel_dvo_destroy,
         .fill_modes = drm_helper_probe_single_connector_modes,
         .atomic_get_property = intel_connector_atomic_get_property,
@@ -447,7 +448,6 @@ void intel_dvo_init(struct drm_device *dev)
         intel_encoder->compute_config = intel_dvo_compute_config;
         intel_encoder->pre_enable = intel_dvo_pre_enable;
         intel_connector->get_hw_state = intel_dvo_connector_get_hw_state;
-        intel_connector->unregister = intel_connector_unregister;
 
         /* Now, try to find a controller */
         for (i = 0; i < ARRAY_SIZE(intel_dvo_devices); i++) {
diff --git a/drivers/gpu/drm/i915/intel_hdmi.c b/drivers/gpu/drm/i915/intel_hdmi.c
index 6b29da9bba38..d4fc3d436d52 100644
--- a/drivers/gpu/drm/i915/intel_hdmi.c
+++ b/drivers/gpu/drm/i915/intel_hdmi.c
@@ -1774,6 +1774,7 @@ static const struct drm_connector_funcs intel_hdmi_connector_funcs = {
         .fill_modes = drm_helper_probe_single_connector_modes,
         .set_property = intel_hdmi_set_property,
         .atomic_get_property = intel_connector_atomic_get_property,
+        .early_unregister = intel_connector_unregister,
         .destroy = intel_hdmi_destroy,
         .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
         .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
@@ -1906,7 +1907,6 @@ void intel_hdmi_init_connector(struct intel_digital_port *intel_dig_port,
                 intel_connector->get_hw_state = intel_ddi_connector_get_hw_state;
         else
                 intel_connector->get_hw_state = intel_connector_get_hw_state;
-        intel_connector->unregister = intel_connector_unregister;
 
         intel_hdmi_add_properties(intel_hdmi, connector);
 
diff --git a/drivers/gpu/drm/i915/intel_lvds.c b/drivers/gpu/drm/i915/intel_lvds.c
index e06b9036bebc..e9082185a375 100644
--- a/drivers/gpu/drm/i915/intel_lvds.c
+++ b/drivers/gpu/drm/i915/intel_lvds.c
@@ -555,6 +555,7 @@ static const struct drm_connector_funcs intel_lvds_connector_funcs = {
         .fill_modes = drm_helper_probe_single_connector_modes,
         .set_property = intel_lvds_set_property,
         .atomic_get_property = intel_connector_atomic_get_property,
+        .early_unregister = intel_connector_unregister,
         .destroy = intel_lvds_destroy,
         .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
         .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
@@ -991,7 +992,6 @@ void intel_lvds_init(struct drm_device *dev)
         intel_encoder->get_hw_state = intel_lvds_get_hw_state;
         intel_encoder->get_config = intel_lvds_get_config;
         intel_connector->get_hw_state = intel_connector_get_hw_state;
-        intel_connector->unregister = intel_connector_unregister;
 
         intel_connector_attach_encoder(intel_connector, intel_encoder);
         intel_encoder->type = INTEL_OUTPUT_LVDS;
diff --git a/drivers/gpu/drm/i915/intel_panel.c b/drivers/gpu/drm/i915/intel_panel.c
index f0b1602c3258..bf721781c259 100644
--- a/drivers/gpu/drm/i915/intel_panel.c
+++ b/drivers/gpu/drm/i915/intel_panel.c
@@ -1216,7 +1216,7 @@ static int intel_backlight_device_register(struct intel_connector *connector)
         return 0;
 }
 
-static void intel_backlight_device_unregister(struct intel_connector *connector)
+void intel_backlight_device_unregister(struct intel_connector *connector)
 {
         struct intel_panel *panel = &connector->panel;
 
@@ -1230,9 +1230,6 @@ static int intel_backlight_device_register(struct intel_connector *connector)
 {
         return 0;
 }
-static void intel_backlight_device_unregister(struct intel_connector *connector)
-{
-}
 #endif /* CONFIG_BACKLIGHT_CLASS_DEVICE */
 
 /*
@@ -1820,11 +1817,3 @@ void intel_backlight_register(struct drm_device *dev)
         for_each_intel_connector(dev, connector)
                 intel_backlight_device_register(connector);
 }
-
-void intel_backlight_unregister(struct drm_device *dev)
-{
-        struct intel_connector *connector;
-
-        for_each_intel_connector(dev, connector)
-                intel_backlight_device_unregister(connector);
-}
diff --git a/drivers/gpu/drm/i915/intel_sdvo.c b/drivers/gpu/drm/i915/intel_sdvo.c
index ab2d0658abe6..02b4a6695528 100644
--- a/drivers/gpu/drm/i915/intel_sdvo.c
+++ b/drivers/gpu/drm/i915/intel_sdvo.c
@@ -2177,12 +2177,23 @@ done:
 #undef CHECK_PROPERTY
 }
 
+static void
+intel_sdvo_connector_unregister(struct drm_connector *connector)
+{
+        struct intel_sdvo *sdvo = intel_attached_sdvo(connector);
+
+        sysfs_remove_link(&connector->kdev->kobj,
+                          sdvo->ddc.dev.kobj.name);
+        intel_connector_unregister(connector);
+}
+
 static const struct drm_connector_funcs intel_sdvo_connector_funcs = {
         .dpms = drm_atomic_helper_connector_dpms,
         .detect = intel_sdvo_detect,
         .fill_modes = drm_helper_probe_single_connector_modes,
         .set_property = intel_sdvo_set_property,
         .atomic_get_property = intel_connector_atomic_get_property,
+        .early_unregister = intel_sdvo_connector_unregister,
         .destroy = intel_sdvo_destroy,
         .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
         .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
@@ -2345,20 +2356,6 @@ intel_sdvo_get_slave_addr(struct drm_device *dev, struct intel_sdvo *sdvo)
                 return 0x72;
 }
 
-static void
-intel_sdvo_connector_unregister(struct intel_connector *intel_connector)
-{
-        struct drm_connector *drm_connector;
-        struct intel_sdvo *sdvo_encoder;
-
-        drm_connector = &intel_connector->base;
-        sdvo_encoder = intel_attached_sdvo(&intel_connector->base);
-
-        sysfs_remove_link(&drm_connector->kdev->kobj,
-                          sdvo_encoder->ddc.dev.kobj.name);
-        intel_connector_unregister(intel_connector);
-}
-
 static int
 intel_sdvo_connector_init(struct intel_sdvo_connector *connector,
                           struct intel_sdvo *encoder)
@@ -2381,7 +2378,6 @@ intel_sdvo_connector_init(struct intel_sdvo_connector *connector,
         connector->base.base.doublescan_allowed = 0;
         connector->base.base.display_info.subpixel_order = SubPixelHorizontalRGB;
         connector->base.get_hw_state = intel_sdvo_connector_get_hw_state;
-        connector->base.unregister = intel_sdvo_connector_unregister;
 
         intel_connector_attach_encoder(&connector->base, &encoder->base);
         ret = drm_connector_register(drm_connector);
diff --git a/drivers/gpu/drm/i915/intel_tv.c b/drivers/gpu/drm/i915/intel_tv.c
index 7ac9e9b0e2c3..4ce70a9f9df2 100644
--- a/drivers/gpu/drm/i915/intel_tv.c
+++ b/drivers/gpu/drm/i915/intel_tv.c
@@ -1501,6 +1501,7 @@ out:
 static const struct drm_connector_funcs intel_tv_connector_funcs = {
         .dpms = drm_atomic_helper_connector_dpms,
         .detect = intel_tv_detect,
+        .early_unregister = intel_connector_unregister,
         .destroy = intel_tv_destroy,
         .set_property = intel_tv_set_property,
         .atomic_get_property = intel_connector_atomic_get_property,
@@ -1599,7 +1600,6 @@ intel_tv_init(struct drm_device *dev)
         intel_encoder->disable = intel_disable_tv;
         intel_encoder->get_hw_state = intel_tv_get_hw_state;
         intel_connector->get_hw_state = intel_connector_get_hw_state;
-        intel_connector->unregister = intel_connector_unregister;
 
         intel_connector_attach_encoder(intel_connector, intel_encoder);
         intel_encoder->type = INTEL_OUTPUT_TVOUT;
diff --git a/drivers/gpu/drm/imx/imx-drm-core.c b/drivers/gpu/drm/imx/imx-drm-core.c
index 82656654fb21..7746418a4c08 100644
--- a/drivers/gpu/drm/imx/imx-drm-core.c
+++ b/drivers/gpu/drm/imx/imx-drm-core.c
@@ -407,7 +407,6 @@ static struct drm_driver imx_drm_driver = {
         .load                   = imx_drm_driver_load,
         .unload                 = imx_drm_driver_unload,
         .lastclose              = imx_drm_driver_lastclose,
-        .set_busid              = drm_platform_set_busid,
         .gem_free_object_unlocked = drm_gem_cma_free_object,
         .gem_vm_ops             = &drm_gem_cma_vm_ops,
         .dumb_create            = drm_gem_cma_dumb_create,
diff --git a/drivers/gpu/drm/mediatek/Kconfig b/drivers/gpu/drm/mediatek/Kconfig
index eeefc971801a..9eefecedc3da 100644
--- a/drivers/gpu/drm/mediatek/Kconfig
+++ b/drivers/gpu/drm/mediatek/Kconfig
@@ -6,7 +6,6 @@ config DRM_MEDIATEK
         select DRM_KMS_HELPER
         select DRM_MIPI_DSI
         select DRM_PANEL
-        select IOMMU_DMA
         select MEMORY
         select MTK_SMI
         help
diff --git a/drivers/gpu/drm/mediatek/mtk_drm_drv.c b/drivers/gpu/drm/mediatek/mtk_drm_drv.c
index c33bf98c5d5e..eebb7d881c2b 100644
--- a/drivers/gpu/drm/mediatek/mtk_drm_drv.c
+++ b/drivers/gpu/drm/mediatek/mtk_drm_drv.c
@@ -280,8 +280,6 @@ static int mtk_drm_bind(struct device *dev)
         if (!drm)
                 return -ENOMEM;
 
-        drm_dev_set_unique(drm, dev_name(dev));
-
         drm->dev_private = private;
         private->drm = drm;
 
@@ -293,14 +291,8 @@ static int mtk_drm_bind(struct device *dev)
         if (ret < 0)
                 goto err_deinit;
 
-        ret = drm_connector_register_all(drm);
-        if (ret < 0)
-                goto err_unregister;
-
         return 0;
 
-err_unregister:
-        drm_dev_unregister(drm);
 err_deinit:
         mtk_drm_kms_deinit(drm);
 err_free:
@@ -455,7 +447,6 @@ static int mtk_drm_remove(struct platform_device *pdev)
         struct drm_device *drm = private->drm;
         int i;
 
-        drm_connector_unregister_all(drm);
         drm_dev_unregister(drm);
         mtk_drm_kms_deinit(drm);
         drm_dev_unref(drm);
diff --git a/drivers/gpu/drm/mediatek/mtk_drm_plane.c b/drivers/gpu/drm/mediatek/mtk_drm_plane.c
index 51bc8988fc26..3995765a90dc 100644
--- a/drivers/gpu/drm/mediatek/mtk_drm_plane.c
+++ b/drivers/gpu/drm/mediatek/mtk_drm_plane.c
@@ -170,6 +170,7 @@ static int mtk_plane_atomic_check(struct drm_plane *plane,
 
         return drm_plane_helper_check_update(plane, state->crtc, fb,
                                              &src, &dest, &clip,
+                                             state->rotation,
                                              DRM_PLANE_HELPER_NO_SCALING,
                                              DRM_PLANE_HELPER_NO_SCALING,
                                              true, true, &visible);
diff --git a/drivers/gpu/drm/msm/msm_drv.c b/drivers/gpu/drm/msm/msm_drv.c
index 9c654092ef78..a02dc2b27739 100644
--- a/drivers/gpu/drm/msm/msm_drv.c
+++ b/drivers/gpu/drm/msm/msm_drv.c
@@ -197,8 +197,6 @@ static int msm_drm_uninit(struct device *dev)
 
         drm_kms_helper_poll_fini(ddev);
 
-        drm_connector_unregister_all(ddev);
-
         drm_dev_unregister(ddev);
 
 #ifdef CONFIG_DRM_FBDEV_EMULATION
@@ -431,12 +429,6 @@ static int msm_drm_init(struct device *dev, struct drm_driver *drv)
         if (ret)
                 goto fail;
 
-        ret = drm_connector_register_all(ddev);
-        if (ret) {
-                dev_err(dev, "failed to register connectors\n");
-                goto fail;
-        }
-
         drm_mode_config_reset(ddev);
 
 #ifdef CONFIG_DRM_FBDEV_EMULATION
@@ -730,7 +722,6 @@ static struct drm_driver msm_driver = {
         .open               = msm_open,
         .preclose           = msm_preclose,
         .lastclose          = msm_lastclose,
-        .set_busid          = drm_platform_set_busid,
         .irq_handler        = msm_irq,
         .irq_preinstall     = msm_irq_preinstall,
         .irq_postinstall    = msm_irq_postinstall,
diff --git a/drivers/gpu/drm/nouveau/nouveau_drm.c b/drivers/gpu/drm/nouveau/nouveau_drm.c
index c00ff6e786a3..295e7621cc68 100644
--- a/drivers/gpu/drm/nouveau/nouveau_drm.c
+++ b/drivers/gpu/drm/nouveau/nouveau_drm.c
@@ -1070,7 +1070,6 @@ nouveau_drm_init(void)
         driver_pci = driver_stub;
         driver_pci.set_busid = drm_pci_set_busid;
         driver_platform = driver_stub;
-        driver_platform.set_busid = drm_platform_set_busid;
 
         nouveau_display_options();
 
diff --git a/drivers/gpu/drm/omapdrm/omap_drv.c b/drivers/gpu/drm/omapdrm/omap_drv.c
index 6b97011154bf..26c6134eb744 100644
--- a/drivers/gpu/drm/omapdrm/omap_drv.c
+++ b/drivers/gpu/drm/omapdrm/omap_drv.c
@@ -801,7 +801,6 @@ static struct drm_driver omap_drm_driver = {
         .unload = dev_unload,
         .open = dev_open,
         .lastclose = dev_lastclose,
-        .set_busid = drm_platform_set_busid,
         .get_vblank_counter = drm_vblank_no_hw_counter,
         .enable_vblank = omap_irq_enable_vblank,
         .disable_vblank = omap_irq_disable_vblank,
diff --git a/drivers/gpu/drm/omapdrm/omap_fbdev.c b/drivers/gpu/drm/omapdrm/omap_fbdev.c
index 31dfa0893416..adb10fbe918d 100644
--- a/drivers/gpu/drm/omapdrm/omap_fbdev.c
+++ b/drivers/gpu/drm/omapdrm/omap_fbdev.c
@@ -279,9 +279,6 @@ struct drm_fb_helper *omap_fbdev_init(struct drm_device *dev)
         if (ret)
                 goto fini;
 
-        /* disable all the possible outputs/crtcs before entering KMS mode */
-        drm_helper_disable_unused_functions(dev);
-
         ret = drm_fb_helper_initial_config(helper, 32);
         if (ret)
                 goto fini;
diff --git a/drivers/gpu/drm/rcar-du/rcar_du_drv.c b/drivers/gpu/drm/rcar-du/rcar_du_drv.c
index 48ec4b6e8b26..d1c0512e4a9e 100644
--- a/drivers/gpu/drm/rcar-du/rcar_du_drv.c
+++ b/drivers/gpu/drm/rcar-du/rcar_du_drv.c
@@ -278,7 +278,6 @@ static int rcar_du_remove(struct platform_device *pdev)
         struct rcar_du_device *rcdu = platform_get_drvdata(pdev);
         struct drm_device *ddev = rcdu->ddev;
 
-        drm_connector_unregister_all(ddev);
         drm_dev_unregister(ddev);
 
         if (rcdu->fbdev)
@@ -320,8 +319,6 @@ static int rcar_du_probe(struct platform_device *pdev)
         if (!ddev)
                 return -ENOMEM;
 
-        drm_dev_set_unique(ddev, dev_name(&pdev->dev));
-
         rcdu->ddev = ddev;
         ddev->dev_private = rcdu;
 
@@ -360,10 +357,6 @@ static int rcar_du_probe(struct platform_device *pdev)
         if (ret)
                 goto error;
 
-        ret = drm_connector_register_all(ddev);
-        if (ret < 0)
-                goto error;
-
         DRM_INFO("Device %s probed\n", dev_name(&pdev->dev));
 
         return 0;
diff --git a/drivers/gpu/drm/rockchip/Kconfig b/drivers/gpu/drm/rockchip/Kconfig
index d30bdc38a760..e48611e83c03 100644
--- a/drivers/gpu/drm/rockchip/Kconfig
+++ b/drivers/gpu/drm/rockchip/Kconfig
@@ -2,6 +2,7 @@ config DRM_ROCKCHIP
         tristate "DRM Support for Rockchip"
         depends on DRM && ROCKCHIP_IOMMU
         depends on RESET_CONTROLLER
+        select DRM_GEM_CMA_HELPER
         select DRM_KMS_HELPER
         select DRM_KMS_FB_HELPER
         select DRM_PANEL
diff --git a/drivers/gpu/drm/rockchip/rockchip_drm_drv.c b/drivers/gpu/drm/rockchip/rockchip_drm_drv.c
index c2bcc5ea1abe..d665fb04d264 100644
--- a/drivers/gpu/drm/rockchip/rockchip_drm_drv.c
+++ b/drivers/gpu/drm/rockchip/rockchip_drm_drv.c
@@ -146,16 +146,12 @@ static int rockchip_drm_bind(struct device *dev)
         if (!drm_dev)
                 return -ENOMEM;
 
-        ret = drm_dev_register(drm_dev, 0);
-        if (ret)
-                goto err_free;
-
         dev_set_drvdata(dev, drm_dev);
 
         private = devm_kzalloc(drm_dev->dev, sizeof(*private), GFP_KERNEL);
         if (!private) {
                 ret = -ENOMEM;
-                goto err_unregister;
+                goto err_free;
         }
 
         drm_dev->dev_private = private;
@@ -197,12 +193,6 @@ static int rockchip_drm_bind(struct device *dev)
         if (ret)
                 goto err_detach_device;
 
-        ret = drm_connector_register_all(drm_dev);
-        if (ret) {
-                dev_err(dev, "failed to register connectors\n");
-                goto err_unbind;
-        }
-
         /* init kms poll for handling hpd */
         drm_kms_helper_poll_init(drm_dev);
 
@@ -222,14 +212,19 @@ static int rockchip_drm_bind(struct device *dev)
         if (ret)
                 goto err_vblank_cleanup;
 
+        ret = drm_dev_register(drm_dev, 0);
+        if (ret)
+                goto err_fbdev_fini;
+
         if (is_support_iommu)
                 arm_iommu_release_mapping(mapping);
         return 0;
+err_fbdev_fini:
+        rockchip_drm_fbdev_fini(drm_dev);
 err_vblank_cleanup:
         drm_vblank_cleanup(drm_dev);
 err_kms_helper_poll_fini:
         drm_kms_helper_poll_fini(drm_dev);
-err_unbind:
         component_unbind_all(dev, drm_dev);
 err_detach_device:
         if (is_support_iommu)
@@ -240,8 +235,6 @@ err_release_mapping:
 err_config_cleanup:
         drm_mode_config_cleanup(drm_dev);
         drm_dev->dev_private = NULL;
-err_unregister:
-        drm_dev_unregister(drm_dev);
 err_free:
         drm_dev_unref(drm_dev);
         return ret;
diff --git a/drivers/gpu/drm/rockchip/rockchip_drm_vop.c b/drivers/gpu/drm/rockchip/rockchip_drm_vop.c
index 8cd840f602b7..6255e5bcd954 100644
--- a/drivers/gpu/drm/rockchip/rockchip_drm_vop.c
+++ b/drivers/gpu/drm/rockchip/rockchip_drm_vop.c
@@ -626,6 +626,7 @@ static int vop_plane_atomic_check(struct drm_plane *plane,
 
         ret = drm_plane_helper_check_update(plane, crtc, state->fb,
                                             src, dest, &clip,
+                                            state->rotation,
                                             min_scale,
                                             max_scale,
                                             true, true, &visible);
diff --git a/drivers/gpu/drm/shmobile/shmob_drm_drv.c b/drivers/gpu/drm/shmobile/shmob_drm_drv.c
index ee79264b5b6a..f0492603ea88 100644
--- a/drivers/gpu/drm/shmobile/shmob_drm_drv.c
+++ b/drivers/gpu/drm/shmobile/shmob_drm_drv.c
@@ -259,7 +259,6 @@ static struct drm_driver shmob_drm_driver = {
                                 | DRIVER_PRIME,
         .load                   = shmob_drm_load,
         .unload                 = shmob_drm_unload,
-        .set_busid              = drm_platform_set_busid,
         .irq_handler            = shmob_drm_irq,
         .get_vblank_counter     = drm_vblank_no_hw_counter,
         .enable_vblank          = shmob_drm_enable_vblank,
diff --git a/drivers/gpu/drm/sis/sis_mm.c b/drivers/gpu/drm/sis/sis_mm.c
index 93ad8a5704d1..03defda77766 100644
--- a/drivers/gpu/drm/sis/sis_mm.c
+++ b/drivers/gpu/drm/sis/sis_mm.c
@@ -316,7 +316,7 @@ void sis_reclaim_buffers_locked(struct drm_device *dev,
         struct sis_file_private *file_priv = file->driver_priv;
         struct sis_memblock *entry, *next;
 
-        if (!(file->minor->master && file->master->lock.hw_lock))
+        if (!(dev->master && file->master->lock.hw_lock))
                 return;
 
         drm_legacy_idlelock_take(&file->master->lock);
diff --git a/drivers/gpu/drm/sti/sti_compositor.c b/drivers/gpu/drm/sti/sti_compositor.c
index 3d2fa3ab33df..794148ff0e57 100644
--- a/drivers/gpu/drm/sti/sti_compositor.c
+++ b/drivers/gpu/drm/sti/sti_compositor.c
@@ -55,6 +55,26 @@ struct sti_compositor_data stih416_compositor_data = {
         },
 };
 
+int sti_compositor_debufs_init(struct sti_compositor *compo,
+                               struct drm_minor *minor)
+{
+        int ret = 0, i;
+
+        for (i = 0; compo->vid[i]; i++) {
+                ret = vid_debugfs_init(compo->vid[i], minor);
+                if (ret)
+                        return ret;
+        }
+
+        for (i = 0; compo->mixer[i]; i++) {
+                ret = sti_mixer_debugfs_init(compo->mixer[i], minor);
+                if (ret)
+                        return ret;
+        }
+
+        return 0;
+}
+
 static int sti_compositor_bind(struct device *dev,
                                struct device *master,
                                void *data)
diff --git a/drivers/gpu/drm/sti/sti_compositor.h b/drivers/gpu/drm/sti/sti_compositor.h
index 1a4a73dab11e..24444ef42a98 100644
--- a/drivers/gpu/drm/sti/sti_compositor.h
+++ b/drivers/gpu/drm/sti/sti_compositor.h
@@ -81,4 +81,7 @@ struct sti_compositor {
         struct notifier_block vtg_vblank_nb;
 };
 
+int sti_compositor_debufs_init(struct sti_compositor *compo,
+                               struct drm_minor *minor);
+
 #endif
diff --git a/drivers/gpu/drm/sti/sti_crtc.c b/drivers/gpu/drm/sti/sti_crtc.c
index e04deedabd4a..7fab3af7473b 100644
--- a/drivers/gpu/drm/sti/sti_crtc.c
+++ b/drivers/gpu/drm/sti/sti_crtc.c
@@ -331,6 +331,17 @@ void sti_crtc_disable_vblank(struct drm_device *drm_dev, unsigned int pipe)
         }
 }
 
+static int sti_crtc_late_register(struct drm_crtc *crtc)
+{
+        struct sti_mixer *mixer = to_sti_mixer(crtc);
+        struct sti_compositor *compo = dev_get_drvdata(mixer->dev);
+
+        if (drm_crtc_index(crtc) == 0)
+                return sti_compositor_debufs_init(compo, crtc->dev->primary);
+
+        return 0;
+}
+
 static const struct drm_crtc_funcs sti_crtc_funcs = {
         .set_config = drm_atomic_helper_set_config,
         .page_flip = drm_atomic_helper_page_flip,
@@ -339,6 +350,7 @@ static const struct drm_crtc_funcs sti_crtc_funcs = {
         .reset = drm_atomic_helper_crtc_reset,
         .atomic_duplicate_state = drm_atomic_helper_crtc_duplicate_state,
         .atomic_destroy_state = drm_atomic_helper_crtc_destroy_state,
+        .late_register = sti_crtc_late_register,
 };
 
 bool sti_crtc_is_main(struct drm_crtc *crtc)
diff --git a/drivers/gpu/drm/sti/sti_cursor.c b/drivers/gpu/drm/sti/sti_cursor.c
index 53aa0029295b..a263bbba4119 100644
--- a/drivers/gpu/drm/sti/sti_cursor.c
+++ b/drivers/gpu/drm/sti/sti_cursor.c
@@ -329,6 +329,33 @@ static const struct drm_plane_helper_funcs sti_cursor_helpers_funcs = {
         .atomic_disable = sti_cursor_atomic_disable,
 };
 
+static void sti_cursor_destroy(struct drm_plane *drm_plane)
+{
+        DRM_DEBUG_DRIVER("\n");
+
+        drm_plane_helper_disable(drm_plane);
+        drm_plane_cleanup(drm_plane);
+}
+
+static int sti_cursor_late_register(struct drm_plane *drm_plane)
+{
+        struct sti_plane *plane = to_sti_plane(drm_plane);
+        struct sti_cursor *cursor = to_sti_cursor(plane);
+
+        return cursor_debugfs_init(cursor, drm_plane->dev->primary);
+}
+
+struct drm_plane_funcs sti_cursor_plane_helpers_funcs = {
+        .update_plane = drm_atomic_helper_update_plane,
+        .disable_plane = drm_atomic_helper_disable_plane,
+        .destroy = sti_cursor_destroy,
+        .set_property = sti_plane_set_property,
+        .reset = drm_atomic_helper_plane_reset,
+        .atomic_duplicate_state = drm_atomic_helper_plane_duplicate_state,
+        .atomic_destroy_state = drm_atomic_helper_plane_destroy_state,
+        .late_register = sti_cursor_late_register,
+};
+
 struct drm_plane *sti_cursor_create(struct drm_device *drm_dev,
                                     struct device *dev, int desc,
                                     void __iomem *baseaddr,
@@ -363,7 +390,7 @@ struct drm_plane *sti_cursor_create(struct drm_device *drm_dev,
 
         res = drm_universal_plane_init(drm_dev, &cursor->plane.drm_plane,
                                        possible_crtcs,
-                                       &sti_plane_helpers_funcs,
+                                       &sti_cursor_plane_helpers_funcs,
                                        cursor_supported_formats,
                                        ARRAY_SIZE(cursor_supported_formats),
                                        DRM_PLANE_TYPE_CURSOR, NULL);
@@ -377,9 +404,6 @@ struct drm_plane *sti_cursor_create(struct drm_device *drm_dev,
 
         sti_plane_init_property(&cursor->plane, DRM_PLANE_TYPE_CURSOR);
 
-        if (cursor_debugfs_init(cursor, drm_dev->primary))
-                DRM_ERROR("CURSOR debugfs setup failed\n");
-
         return &cursor->plane.drm_plane;
 
 err_plane:
diff --git a/drivers/gpu/drm/sti/sti_drv.c b/drivers/gpu/drm/sti/sti_drv.c
index dd2c400c4a46..96bd3d08b2d4 100644
--- a/drivers/gpu/drm/sti/sti_drv.c
+++ b/drivers/gpu/drm/sti/sti_drv.c
@@ -226,8 +226,28 @@ static int sti_atomic_commit(struct drm_device *drm,
         return 0;
 }
 
+static void sti_output_poll_changed(struct drm_device *ddev)
+{
+        struct sti_private *private = ddev->dev_private;
+
+        if (!ddev->mode_config.num_connector)
+                return;
+
+        if (private->fbdev) {
+                drm_fbdev_cma_hotplug_event(private->fbdev);
+                return;
+        }
+
+        private->fbdev = drm_fbdev_cma_init(ddev, 32,
+                                            ddev->mode_config.num_crtc,
+                                            ddev->mode_config.num_connector);
+        if (IS_ERR(private->fbdev))
+                private->fbdev = NULL;
+}
+
 static const struct drm_mode_config_funcs sti_mode_config_funcs = {
         .fb_create = drm_fb_cma_create,
+        .output_poll_changed = sti_output_poll_changed,
         .atomic_check = drm_atomic_helper_check,
         .atomic_commit = sti_atomic_commit,
 };
@@ -248,45 +268,6 @@ static void sti_mode_config_init(struct drm_device *dev)
         dev->mode_config.funcs = &sti_mode_config_funcs;
 }
 
-static int sti_load(struct drm_device *dev, unsigned long flags)
-{
-        struct sti_private *private;
-        int ret;
-
-        private = kzalloc(sizeof(*private), GFP_KERNEL);
-        if (!private) {
-                DRM_ERROR("Failed to allocate private\n");
-                return -ENOMEM;
-        }
-        dev->dev_private = (void *)private;
-        private->drm_dev = dev;
-
-        mutex_init(&private->commit.lock);
-        INIT_WORK(&private->commit.work, sti_atomic_work);
-
-        drm_mode_config_init(dev);
-        drm_kms_helper_poll_init(dev);
-
-        sti_mode_config_init(dev);
-
-        ret = component_bind_all(dev->dev, dev);
-        if (ret) {
-                drm_kms_helper_poll_fini(dev);
-                drm_mode_config_cleanup(dev);
-                kfree(private);
-                return ret;
-        }
-
-        drm_mode_config_reset(dev);
-
-        drm_helper_disable_unused_functions(dev);
-        drm_fbdev_cma_init(dev, 32,
-                           dev->mode_config.num_crtc,
-                           dev->mode_config.num_connector);
-
-        return 0;
-}
-
 static const struct file_operations sti_driver_fops = {
         .owner = THIS_MODULE,
         .open = drm_open,
@@ -303,7 +284,6 @@ static const struct file_operations sti_driver_fops = {
 static struct drm_driver sti_driver = {
         .driver_features = DRIVER_HAVE_IRQ | DRIVER_MODESET |
             DRIVER_GEM | DRIVER_PRIME | DRIVER_ATOMIC,
-        .load = sti_load,
         .gem_free_object_unlocked = drm_gem_cma_free_object,
         .gem_vm_ops = &drm_gem_cma_vm_ops,
         .dumb_create = drm_gem_cma_dumb_create,
@@ -340,14 +320,88 @@ static int compare_of(struct device *dev, void *data)
         return dev->of_node == data;
 }
 
+static int sti_init(struct drm_device *ddev)
+{
+        struct sti_private *private;
+
+        private = kzalloc(sizeof(*private), GFP_KERNEL);
+        if (!private)
+                return -ENOMEM;
+
+        ddev->dev_private = (void *)private;
+        dev_set_drvdata(ddev->dev, ddev);
+        private->drm_dev = ddev;
+
+        mutex_init(&private->commit.lock);
+        INIT_WORK(&private->commit.work, sti_atomic_work);
+
+        drm_mode_config_init(ddev);
+
+        sti_mode_config_init(ddev);
+
+        drm_kms_helper_poll_init(ddev);
+
+        return 0;
+}
+
+static void sti_cleanup(struct drm_device *ddev)
+{
+        struct sti_private *private = ddev->dev_private;
+
+        if (private->fbdev) {
+                drm_fbdev_cma_fini(private->fbdev);
+                private->fbdev = NULL;
+        }
+
+        drm_kms_helper_poll_fini(ddev);
+        drm_vblank_cleanup(ddev);
+        kfree(private);
+        ddev->dev_private = NULL;
+}
+
 static int sti_bind(struct device *dev)
 {
-        return drm_platform_init(&sti_driver, to_platform_device(dev));
+        struct drm_device *ddev;
+        int ret;
+
+        ddev = drm_dev_alloc(&sti_driver, dev);
+        if (!ddev)
+                return -ENOMEM;
+
+        ddev->platformdev = to_platform_device(dev);
+
+        ret = sti_init(ddev);
+        if (ret)
+                goto err_drm_dev_unref;
+
+        ret = component_bind_all(ddev->dev, ddev);
+        if (ret)
+                goto err_cleanup;
+
+        ret = drm_dev_register(ddev, 0);
+        if (ret)
+                goto err_register;
+
+        drm_mode_config_reset(ddev);
+
+        return 0;
+
+err_register:
+        drm_mode_config_cleanup(ddev);
+err_cleanup:
+        sti_cleanup(ddev);
+err_drm_dev_unref:
+        drm_dev_unref(ddev);
+        return ret;
 }
 
 static void sti_unbind(struct device *dev)
 {
-        drm_put_dev(dev_get_drvdata(dev));
+        struct drm_device *ddev = dev_get_drvdata(dev);
+
+        drm_dev_unregister(ddev);
+        sti_cleanup(ddev);
+        drm_dev_unref(ddev);
 }
 
 static const struct component_master_ops sti_ops = {
diff --git a/drivers/gpu/drm/sti/sti_drv.h b/drivers/gpu/drm/sti/sti_drv.h
index 30ddc20841c3..78ebe5e30f53 100644
--- a/drivers/gpu/drm/sti/sti_drv.h
+++ b/drivers/gpu/drm/sti/sti_drv.h
@@ -24,6 +24,7 @@ struct sti_private {
         struct sti_compositor *compo;
         struct drm_property *plane_zorder_property;
         struct drm_device *drm_dev;
+        struct drm_fbdev_cma *fbdev;
 
         struct {
                 struct drm_atomic_state *state;
diff --git a/drivers/gpu/drm/sti/sti_dvo.c b/drivers/gpu/drm/sti/sti_dvo.c
index e2901667eceb..ec3108074350 100644
--- a/drivers/gpu/drm/sti/sti_dvo.c
+++ b/drivers/gpu/drm/sti/sti_dvo.c
@@ -404,24 +404,29 @@ sti_dvo_connector_detect(struct drm_connector *connector, bool force)
         return connector_status_disconnected;
 }
 
-static void sti_dvo_connector_destroy(struct drm_connector *connector)
+static int sti_dvo_late_register(struct drm_connector *connector)
 {
         struct sti_dvo_connector *dvo_connector
                 = to_sti_dvo_connector(connector);
+        struct sti_dvo *dvo = dvo_connector->dvo;
+
+        if (dvo_debugfs_init(dvo, dvo->drm_dev->primary)) {
+                DRM_ERROR("DVO debugfs setup failed\n");
+                return -EINVAL;
+        }
 
-        drm_connector_unregister(connector);
-        drm_connector_cleanup(connector);
-        kfree(dvo_connector);
+        return 0;
 }
 
 static const struct drm_connector_funcs sti_dvo_connector_funcs = {
         .dpms = drm_atomic_helper_connector_dpms,
         .fill_modes = drm_helper_probe_single_connector_modes,
         .detect = sti_dvo_connector_detect,
-        .destroy = sti_dvo_connector_destroy,
+        .destroy = drm_connector_cleanup,
         .reset = drm_atomic_helper_connector_reset,
         .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
         .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
+        .late_register = sti_dvo_late_register,
 };
 
 static struct drm_encoder *sti_dvo_find_encoder(struct drm_device *dev)
@@ -492,26 +497,16 @@ static int sti_dvo_bind(struct device *dev, struct device *master, void *data)
         drm_connector_helper_add(drm_connector,
                                  &sti_dvo_connector_helper_funcs);
 
-        err = drm_connector_register(drm_connector);
-        if (err)
-                goto err_connector;
-
         err = drm_mode_connector_attach_encoder(drm_connector, encoder);
         if (err) {
                 DRM_ERROR("Failed to attach a connector to a encoder\n");
                 goto err_sysfs;
         }
 
-        if (dvo_debugfs_init(dvo, drm_dev->primary))
-                DRM_ERROR("DVO debugfs setup failed\n");
-
         return 0;
 
 err_sysfs:
-        drm_connector_unregister(drm_connector);
-err_connector:
         drm_bridge_remove(bridge);
-        drm_connector_cleanup(drm_connector);
         return -EINVAL;
 }
 
diff --git a/drivers/gpu/drm/sti/sti_gdp.c b/drivers/gpu/drm/sti/sti_gdp.c
index fdf69b5a041b..bf63086a3dc8 100644
--- a/drivers/gpu/drm/sti/sti_gdp.c
+++ b/drivers/gpu/drm/sti/sti_gdp.c
@@ -866,6 +866,33 @@ static const struct drm_plane_helper_funcs sti_gdp_helpers_funcs = {
         .atomic_disable = sti_gdp_atomic_disable,
 };
 
+static void sti_gdp_destroy(struct drm_plane *drm_plane)
+{
+        DRM_DEBUG_DRIVER("\n");
+
+        drm_plane_helper_disable(drm_plane);
+        drm_plane_cleanup(drm_plane);
+}
+
+static int sti_gdp_late_register(struct drm_plane *drm_plane)
+{
+        struct sti_plane *plane = to_sti_plane(drm_plane);
+        struct sti_gdp *gdp = to_sti_gdp(plane);
+
+        return gdp_debugfs_init(gdp, drm_plane->dev->primary);
+}
+
+struct drm_plane_funcs sti_gdp_plane_helpers_funcs = {
+        .update_plane = drm_atomic_helper_update_plane,
+        .disable_plane = drm_atomic_helper_disable_plane,
+        .destroy = sti_gdp_destroy,
+        .set_property = sti_plane_set_property,
+        .reset = drm_atomic_helper_plane_reset,
+        .atomic_duplicate_state = drm_atomic_helper_plane_duplicate_state,
+        .atomic_destroy_state = drm_atomic_helper_plane_destroy_state,
+        .late_register = sti_gdp_late_register,
+};
+
 struct drm_plane *sti_gdp_create(struct drm_device *drm_dev,
                                  struct device *dev, int desc,
                                  void __iomem *baseaddr,
@@ -892,7 +919,7 @@ struct drm_plane *sti_gdp_create(struct drm_device *drm_dev,
 
         res = drm_universal_plane_init(drm_dev, &gdp->plane.drm_plane,
                                        possible_crtcs,
-                                       &sti_plane_helpers_funcs,
+                                       &sti_gdp_plane_helpers_funcs,
                                        gdp_supported_formats,
                                        ARRAY_SIZE(gdp_supported_formats),
                                        type, NULL);
@@ -905,9 +932,6 @@ struct drm_plane *sti_gdp_create(struct drm_device *drm_dev,
 
         sti_plane_init_property(&gdp->plane, type);
 
-        if (gdp_debugfs_init(gdp, drm_dev->primary))
-                DRM_ERROR("GDP debugfs setup failed\n");
-
         return &gdp->plane.drm_plane;
 
 err:
diff --git a/drivers/gpu/drm/sti/sti_hda.c b/drivers/gpu/drm/sti/sti_hda.c
index dcec5a8eda59..8505569f75de 100644
--- a/drivers/gpu/drm/sti/sti_hda.c
+++ b/drivers/gpu/drm/sti/sti_hda.c
@@ -681,24 +681,29 @@ sti_hda_connector_detect(struct drm_connector *connector, bool force)
         return connector_status_connected;
 }
 
-static void sti_hda_connector_destroy(struct drm_connector *connector)
+static int sti_hda_late_register(struct drm_connector *connector)
 {
         struct sti_hda_connector *hda_connector
                 = to_sti_hda_connector(connector);
+        struct sti_hda *hda = hda_connector->hda;
+
+        if (hda_debugfs_init(hda, hda->drm_dev->primary)) {
+                DRM_ERROR("HDA debugfs setup failed\n");
+                return -EINVAL;
+        }
 
-        drm_connector_unregister(connector);
-        drm_connector_cleanup(connector);
-        kfree(hda_connector);
+        return 0;
 }
 
 static const struct drm_connector_funcs sti_hda_connector_funcs = {
         .dpms = drm_atomic_helper_connector_dpms,
         .fill_modes = drm_helper_probe_single_connector_modes,
         .detect = sti_hda_connector_detect,
-        .destroy = sti_hda_connector_destroy,
+        .destroy = drm_connector_cleanup,
         .reset = drm_atomic_helper_connector_reset,
         .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
         .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
+        .late_register = sti_hda_late_register,
 };
 
 static struct drm_encoder *sti_hda_find_encoder(struct drm_device *dev)
@@ -756,10 +761,6 @@ static int sti_hda_bind(struct device *dev, struct device *master, void *data)
         drm_connector_helper_add(drm_connector,
                         &sti_hda_connector_helper_funcs);
 
-        err = drm_connector_register(drm_connector);
-        if (err)
-                goto err_connector;
-
         err = drm_mode_connector_attach_encoder(drm_connector, encoder);
         if (err) {
                 DRM_ERROR("Failed to attach a connector to a encoder\n");
@@ -769,15 +770,10 @@ static int sti_hda_bind(struct device *dev, struct device *master, void *data)
         /* force to disable hd dacs at startup */
         hda_enable_hd_dacs(hda, false);
 
-        if (hda_debugfs_init(hda, drm_dev->primary))
-                DRM_ERROR("HDA debugfs setup failed\n");
-
         return 0;
 
 err_sysfs:
-        drm_connector_unregister(drm_connector);
-err_connector:
-        drm_connector_cleanup(drm_connector);
+        drm_bridge_remove(bridge);
         return -EINVAL;
 }
 
diff --git a/drivers/gpu/drm/sti/sti_hdmi.c b/drivers/gpu/drm/sti/sti_hdmi.c
index 36d9d6635784..8d1402b245bf 100644
--- a/drivers/gpu/drm/sti/sti_hdmi.c
+++ b/drivers/gpu/drm/sti/sti_hdmi.c
@@ -915,16 +915,6 @@ sti_hdmi_connector_detect(struct drm_connector *connector, bool force)
         return connector_status_disconnected;
 }
 
-static void sti_hdmi_connector_destroy(struct drm_connector *connector)
-{
-        struct sti_hdmi_connector *hdmi_connector
-                = to_sti_hdmi_connector(connector);
-
-        drm_connector_unregister(connector);
-        drm_connector_cleanup(connector);
-        kfree(hdmi_connector);
-}
-
 static void sti_hdmi_connector_init_property(struct drm_device *drm_dev,
                                              struct drm_connector *connector)
 {
@@ -1007,17 +997,31 @@ sti_hdmi_connector_get_property(struct drm_connector *connector,
         return -EINVAL;
 }
 
+static int sti_hdmi_late_register(struct drm_connector *connector)
+{
+        struct sti_hdmi_connector *hdmi_connector
+                = to_sti_hdmi_connector(connector);
+        struct sti_hdmi *hdmi = hdmi_connector->hdmi;
+
+        if (hdmi_debugfs_init(hdmi, hdmi->drm_dev->primary)) {
+                DRM_ERROR("HDMI debugfs setup failed\n");
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
 static const struct drm_connector_funcs sti_hdmi_connector_funcs = {
-        .dpms = drm_atomic_helper_connector_dpms,
         .fill_modes = drm_helper_probe_single_connector_modes,
         .detect = sti_hdmi_connector_detect,
-        .destroy = sti_hdmi_connector_destroy,
+        .destroy = drm_connector_cleanup,
         .reset = drm_atomic_helper_connector_reset,
         .set_property = drm_atomic_helper_connector_set_property,
         .atomic_set_property = sti_hdmi_connector_set_property,
         .atomic_get_property = sti_hdmi_connector_get_property,
         .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
         .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
+        .late_register = sti_hdmi_late_register,
 };
 
 static struct drm_encoder *sti_hdmi_find_encoder(struct drm_device *dev)
@@ -1078,10 +1082,6 @@ static int sti_hdmi_bind(struct device *dev, struct device *master, void *data)
         /* initialise property */
         sti_hdmi_connector_init_property(drm_dev, drm_connector);
 
-        err = drm_connector_register(drm_connector);
-        if (err)
-                goto err_connector;
-
         err = drm_mode_connector_attach_encoder(drm_connector, encoder);
         if (err) {
                 DRM_ERROR("Failed to attach a connector to a encoder\n");
@@ -1091,16 +1091,10 @@ static int sti_hdmi_bind(struct device *dev, struct device *master, void *data)
         /* Enable default interrupts */
         hdmi_write(hdmi, HDMI_DEFAULT_INT, HDMI_INT_EN);
 
-        if (hdmi_debugfs_init(hdmi, drm_dev->primary))
-                DRM_ERROR("HDMI debugfs setup failed\n");
-
         return 0;
 
 err_sysfs:
-        drm_connector_unregister(drm_connector);
-err_connector:
-        drm_connector_cleanup(drm_connector);
-
+        drm_bridge_remove(bridge);
         return -EINVAL;
 }
 
diff --git a/drivers/gpu/drm/sti/sti_hqvdp.c b/drivers/gpu/drm/sti/sti_hqvdp.c
index 1c06a50fddca..33d2f42550cc 100644
--- a/drivers/gpu/drm/sti/sti_hqvdp.c
+++ b/drivers/gpu/drm/sti/sti_hqvdp.c
@@ -1234,6 +1234,33 @@ static const struct drm_plane_helper_funcs sti_hqvdp_helpers_funcs = {
         .atomic_disable = sti_hqvdp_atomic_disable,
 };
 
+static void sti_hqvdp_destroy(struct drm_plane *drm_plane)
+{
+        DRM_DEBUG_DRIVER("\n");
+
+        drm_plane_helper_disable(drm_plane);
+        drm_plane_cleanup(drm_plane);
+}
+
+static int sti_hqvdp_late_register(struct drm_plane *drm_plane)
+{
+        struct sti_plane *plane = to_sti_plane(drm_plane);
+        struct sti_hqvdp *hqvdp = to_sti_hqvdp(plane);
+
+        return hqvdp_debugfs_init(hqvdp, drm_plane->dev->primary);
+}
+
+struct drm_plane_funcs sti_hqvdp_plane_helpers_funcs = {
+        .update_plane = drm_atomic_helper_update_plane,
+        .disable_plane = drm_atomic_helper_disable_plane,
+        .destroy = sti_hqvdp_destroy,
+        .set_property = sti_plane_set_property,
+        .reset = drm_atomic_helper_plane_reset,
+        .atomic_duplicate_state = drm_atomic_helper_plane_duplicate_state,
+        .atomic_destroy_state = drm_atomic_helper_plane_destroy_state,
+        .late_register = sti_hqvdp_late_register,
+};
+
 static struct drm_plane *sti_hqvdp_create(struct drm_device *drm_dev,
                                           struct device *dev, int desc)
 {
@@ -1246,7 +1273,7 @@ static struct drm_plane *sti_hqvdp_create(struct drm_device *drm_dev,
         sti_hqvdp_init(hqvdp);
 
         res = drm_universal_plane_init(drm_dev, &hqvdp->plane.drm_plane, 1,
-                                       &sti_plane_helpers_funcs,
+                                       &sti_hqvdp_plane_helpers_funcs,
                                        hqvdp_supported_formats,
                                        ARRAY_SIZE(hqvdp_supported_formats),
                                        DRM_PLANE_TYPE_OVERLAY, NULL);
@@ -1259,9 +1286,6 @@ static struct drm_plane *sti_hqvdp_create(struct drm_device *drm_dev,
 
         sti_plane_init_property(&hqvdp->plane, DRM_PLANE_TYPE_OVERLAY);
 
-        if (hqvdp_debugfs_init(hqvdp, drm_dev->primary))
-                DRM_ERROR("HQVDP debugfs setup failed\n");
-
         return &hqvdp->plane.drm_plane;
 }
 
diff --git a/drivers/gpu/drm/sti/sti_mixer.c b/drivers/gpu/drm/sti/sti_mixer.c
index 6f86f2b2b6a5..1885c7ab5a8b 100644
--- a/drivers/gpu/drm/sti/sti_mixer.c
+++ b/drivers/gpu/drm/sti/sti_mixer.c
@@ -181,7 +181,7 @@ static struct drm_info_list mixer1_debugfs_files[] = {
         { "mixer_aux", mixer_dbg_show, 0, NULL },
 };
 
-static int mixer_debugfs_init(struct sti_mixer *mixer, struct drm_minor *minor)
+int sti_mixer_debugfs_init(struct sti_mixer *mixer, struct drm_minor *minor)
 {
         unsigned int i;
         struct drm_info_list *mixer_debugfs_files;
@@ -393,8 +393,5 @@ struct sti_mixer *sti_mixer_create(struct device *dev,
         DRM_DEBUG_DRIVER("%s created. Regs=%p\n",
                          sti_mixer_to_str(mixer), mixer->regs);
 
-        if (mixer_debugfs_init(mixer, drm_dev->primary))
-                DRM_ERROR("MIXER debugfs setup failed\n");
-
         return mixer;
 }
diff --git a/drivers/gpu/drm/sti/sti_mixer.h b/drivers/gpu/drm/sti/sti_mixer.h
index 6f35fc086873..830a3c42d886 100644
--- a/drivers/gpu/drm/sti/sti_mixer.h
+++ b/drivers/gpu/drm/sti/sti_mixer.h
@@ -55,6 +55,8 @@ int sti_mixer_active_video_area(struct sti_mixer *mixer,
 
 void sti_mixer_set_background_status(struct sti_mixer *mixer, bool enable);
 
+int sti_mixer_debugfs_init(struct sti_mixer *mixer, struct drm_minor *minor);
+
 /* depth in Cross-bar control = z order */
 #define GAM_MIXER_NB_DEPTH_LEVEL 6
 
diff --git a/drivers/gpu/drm/sti/sti_plane.c b/drivers/gpu/drm/sti/sti_plane.c
index f10c98d3f012..85cee9098439 100644
--- a/drivers/gpu/drm/sti/sti_plane.c
+++ b/drivers/gpu/drm/sti/sti_plane.c
@@ -106,17 +106,9 @@ void sti_plane_update_fps(struct sti_plane *plane,
                          plane->fps_info.fips_str);
 }
 
-static void sti_plane_destroy(struct drm_plane *drm_plane)
-{
-        DRM_DEBUG_DRIVER("\n");
-
-        drm_plane_helper_disable(drm_plane);
-        drm_plane_cleanup(drm_plane);
-}
-
-static int sti_plane_set_property(struct drm_plane *drm_plane,
-                                  struct drm_property *property,
-                                  uint64_t val)
+int sti_plane_set_property(struct drm_plane *drm_plane,
+                           struct drm_property *property,
+                           uint64_t val)
 {
         struct drm_device *dev = drm_plane->dev;
         struct sti_private *private = dev->dev_private;
@@ -170,13 +162,3 @@ void sti_plane_init_property(struct sti_plane *plane,
                          plane->drm_plane.base.id,
                          sti_plane_to_str(plane), plane->zorder);
 }
-
-struct drm_plane_funcs sti_plane_helpers_funcs = {
-        .update_plane = drm_atomic_helper_update_plane,
-        .disable_plane = drm_atomic_helper_disable_plane,
-        .destroy = sti_plane_destroy,
-        .set_property = sti_plane_set_property,
-        .reset = drm_atomic_helper_plane_reset,
-        .atomic_duplicate_state = drm_atomic_helper_plane_duplicate_state,
-        .atomic_destroy_state = drm_atomic_helper_plane_destroy_state,
-};
diff --git a/drivers/gpu/drm/sti/sti_plane.h b/drivers/gpu/drm/sti/sti_plane.h
index c50a3b9f5d37..39d39f5b7dd9 100644
--- a/drivers/gpu/drm/sti/sti_plane.h
+++ b/drivers/gpu/drm/sti/sti_plane.h
@@ -11,8 +11,6 @@
 #include <drm/drm_atomic_helper.h>
 #include <drm/drm_plane_helper.h>
 
-extern struct drm_plane_funcs sti_plane_helpers_funcs;
-
 #define to_sti_plane(x) container_of(x, struct sti_plane, drm_plane)
 
 #define STI_PLANE_TYPE_SHIFT 8
@@ -83,6 +81,11 @@ const char *sti_plane_to_str(struct sti_plane *plane);
 void sti_plane_update_fps(struct sti_plane *plane,
                           bool new_frame,
                           bool new_field);
+
+int sti_plane_set_property(struct drm_plane *drm_plane,
+                           struct drm_property *property,
+                           uint64_t val);
+
 void sti_plane_init_property(struct sti_plane *plane,
                              enum drm_plane_type type);
 #endif
diff --git a/drivers/gpu/drm/sti/sti_tvout.c b/drivers/gpu/drm/sti/sti_tvout.c
index 60fe0afa5644..e25995b35715 100644
--- a/drivers/gpu/drm/sti/sti_tvout.c
+++ b/drivers/gpu/drm/sti/sti_tvout.c
@@ -112,6 +112,7 @@ struct sti_tvout {
         struct drm_encoder *hdmi;
         struct drm_encoder *hda;
         struct drm_encoder *dvo;
+        bool debugfs_registered;
 };
 
 struct sti_tvout_encoder {
@@ -625,8 +626,37 @@ static void sti_tvout_encoder_destroy(struct drm_encoder *encoder)
         kfree(sti_encoder);
 }
 
+static int sti_tvout_late_register(struct drm_encoder *encoder)
+{
+        struct sti_tvout *tvout = to_sti_tvout(encoder);
+        int ret;
+
+        if (tvout->debugfs_registered)
+                return 0;
+
+        ret = tvout_debugfs_init(tvout, encoder->dev->primary);
+        if (ret)
+                return ret;
+
+        tvout->debugfs_registered = true;
+        return 0;
+}
+
+static void sti_tvout_early_unregister(struct drm_encoder *encoder)
+{
+        struct sti_tvout *tvout = to_sti_tvout(encoder);
+
+        if (!tvout->debugfs_registered)
+                return;
+
+        tvout_debugfs_exit(tvout, encoder->dev->primary);
+        tvout->debugfs_registered = false;
+}
+
 static const struct drm_encoder_funcs sti_tvout_encoder_funcs = {
         .destroy = sti_tvout_encoder_destroy,
+        .late_register = sti_tvout_late_register,
+        .early_unregister = sti_tvout_early_unregister,
 };
 
 static void sti_dvo_encoder_enable(struct drm_encoder *encoder)
@@ -813,9 +843,6 @@ static int sti_tvout_bind(struct device *dev, struct device *master, void *data)
 
         sti_tvout_create_encoders(drm_dev, tvout);
 
-        if (tvout_debugfs_init(tvout, drm_dev->primary))
-                DRM_ERROR("TVOUT debugfs setup failed\n");
-
         return 0;
 }
 
@@ -823,11 +850,8 @@ static void sti_tvout_unbind(struct device *dev, struct device *master,
         void *data)
 {
         struct sti_tvout *tvout = dev_get_drvdata(dev);
-        struct drm_device *drm_dev = data;
 
         sti_tvout_destroy_encoders(tvout);
-
-        tvout_debugfs_exit(tvout, drm_dev->primary);
 }
 
 static const struct component_ops sti_tvout_ops = {
diff --git a/drivers/gpu/drm/sti/sti_vid.c b/drivers/gpu/drm/sti/sti_vid.c
index 0132aaebe598..47634a0251fc 100644
--- a/drivers/gpu/drm/sti/sti_vid.c
+++ b/drivers/gpu/drm/sti/sti_vid.c
@@ -123,7 +123,7 @@ static struct drm_info_list vid_debugfs_files[] = {
         { "vid", vid_dbg_show, 0, NULL },
 };
 
-static int vid_debugfs_init(struct sti_vid *vid, struct drm_minor *minor)
+int vid_debugfs_init(struct sti_vid *vid, struct drm_minor *minor)
 {
         unsigned int i;
 
@@ -220,8 +220,5 @@ struct sti_vid *sti_vid_create(struct device *dev, struct drm_device *drm_dev,
 
         sti_vid_init(vid);
 
-        if (vid_debugfs_init(vid, drm_dev->primary))
-                DRM_ERROR("VID debugfs setup failed\n");
-
         return vid;
 }
diff --git a/drivers/gpu/drm/sti/sti_vid.h b/drivers/gpu/drm/sti/sti_vid.h
index 6c842344f3d8..fdc90f922a05 100644
--- a/drivers/gpu/drm/sti/sti_vid.h
+++ b/drivers/gpu/drm/sti/sti_vid.h
@@ -26,4 +26,6 @@ void sti_vid_disable(struct sti_vid *vid);
 struct sti_vid *sti_vid_create(struct device *dev, struct drm_device *drm_dev,
                                int id, void __iomem *baseaddr);
 
+int vid_debugfs_init(struct sti_vid *vid, struct drm_minor *minor);
+
 #endif
diff --git a/drivers/gpu/drm/sun4i/sun4i_drv.c b/drivers/gpu/drm/sun4i/sun4i_drv.c
index 68e9d85085fb..9a67f927a53e 100644
--- a/drivers/gpu/drm/sun4i/sun4i_drv.c
+++ b/drivers/gpu/drm/sun4i/sun4i_drv.c
@@ -24,34 +24,6 @@
 #include "sun4i_layer.h"
 #include "sun4i_tcon.h"
 
-static int sun4i_drv_connector_plug_all(struct drm_device *drm)
-{
-        struct drm_connector *connector, *failed;
-        int ret;
-
-        mutex_lock(&drm->mode_config.mutex);
-        list_for_each_entry(connector, &drm->mode_config.connector_list, head) {
-                ret = drm_connector_register(connector);
-                if (ret) {
-                        failed = connector;
-                        goto err;
-                }
-        }
-        mutex_unlock(&drm->mode_config.mutex);
-        return 0;
-
-err:
-        list_for_each_entry(connector, &drm->mode_config.connector_list, head) {
-                if (failed == connector)
-                        break;
-
-                drm_connector_unregister(connector);
-        }
-        mutex_unlock(&drm->mode_config.mutex);
-
-        return ret;
-}
-
 static int sun4i_drv_enable_vblank(struct drm_device *drm, unsigned int pipe)
 {
         struct sun4i_drv *drv = drm->dev_private;
@@ -135,10 +107,6 @@ static int sun4i_drv_bind(struct device *dev)
         if (!drm)
                 return -ENOMEM;
 
-        ret = drm_dev_set_unique(drm, dev_name(drm->dev));
-        if (ret)
-                goto free_drm;
-
         drv = devm_kzalloc(dev, sizeof(*drv), GFP_KERNEL);
         if (!drv) {
                 ret = -ENOMEM;
@@ -187,14 +155,8 @@ static int sun4i_drv_bind(struct device *dev)
         if (ret)
                 goto free_drm;
 
-        ret = sun4i_drv_connector_plug_all(drm);
-        if (ret)
-                goto unregister_drm;
-
         return 0;
 
-unregister_drm:
-        drm_dev_unregister(drm);
 free_drm:
         drm_dev_unref(drm);
         return ret;
diff --git a/drivers/gpu/drm/tilcdc/tilcdc_drv.c b/drivers/gpu/drm/tilcdc/tilcdc_drv.c
index 308e197908fc..d27809372d54 100644
--- a/drivers/gpu/drm/tilcdc/tilcdc_drv.c
+++ b/drivers/gpu/drm/tilcdc/tilcdc_drv.c
@@ -541,7 +541,6 @@ static struct drm_driver tilcdc_driver = {
         .load               = tilcdc_load,
         .unload             = tilcdc_unload,
         .lastclose          = tilcdc_lastclose,
-        .set_busid          = drm_platform_set_busid,
         .irq_handler        = tilcdc_irq,
         .irq_preinstall     = tilcdc_irq_preinstall,
         .irq_postinstall    = tilcdc_irq_postinstall,
diff --git a/drivers/gpu/drm/vc4/vc4_drv.c b/drivers/gpu/drm/vc4/vc4_drv.c
index 58b8fc036332..9e88231b8906 100644
--- a/drivers/gpu/drm/vc4/vc4_drv.c
+++ b/drivers/gpu/drm/vc4/vc4_drv.c
@@ -176,7 +176,6 @@ static int vc4_drm_bind(struct device *dev)
 {
         struct platform_device *pdev = to_platform_device(dev);
         struct drm_device *drm;
-        struct drm_connector *connector;
         struct vc4_dev *vc4;
         int ret = 0;
 
@@ -211,22 +210,10 @@ static int vc4_drm_bind(struct device *dev)
         if (ret < 0)
                 goto unbind_all;
 
-        /* Connector registration has to occur after DRM device
-         * registration, because it creates sysfs entries based on the
-         * DRM device.
-         */
-        list_for_each_entry(connector, &drm->mode_config.connector_list, head) {
-                ret = drm_connector_register(connector);
-                if (ret)
-                        goto unregister;
-        }
-
         vc4_kms_load(drm);
 
         return 0;
 
-unregister:
-        drm_dev_unregister(drm);
 unbind_all:
         component_unbind_all(dev, drm);
 gem_destroy:
diff --git a/drivers/gpu/drm/vgem/vgem_drv.c b/drivers/gpu/drm/vgem/vgem_drv.c
index 1b4cc8b27080..35ea5d02a827 100644
--- a/drivers/gpu/drm/vgem/vgem_drv.c
+++ b/drivers/gpu/drm/vgem/vgem_drv.c
@@ -260,8 +260,6 @@ static int __init vgem_init(void)
                 goto out;
         }
 
-        drm_dev_set_unique(vgem_device, "vgem");
-
         ret  = drm_dev_register(vgem_device, 0);
 
         if (ret)
diff --git a/drivers/gpu/drm/via/via_mm.c b/drivers/gpu/drm/via/via_mm.c
index 4f20742e7788..a04ef1c992d9 100644
--- a/drivers/gpu/drm/via/via_mm.c
+++ b/drivers/gpu/drm/via/via_mm.c
@@ -208,7 +208,7 @@ void via_reclaim_buffers_locked(struct drm_device *dev,
         struct via_file_private *file_priv = file->driver_priv;
         struct via_memblock *entry, *next;
 
-        if (!(file->minor->master && file->master->lock.hw_lock))
+        if (!(dev->master && file->master->lock.hw_lock))
                 return;
 
         drm_legacy_idlelock_take(&file->master->lock);
diff --git a/drivers/gpu/drm/virtio/virtgpu_drm_bus.c b/drivers/gpu/drm/virtio/virtgpu_drm_bus.c
index 88a39165edd5..7f0e93f87a55 100644
--- a/drivers/gpu/drm/virtio/virtgpu_drm_bus.c
+++ b/drivers/gpu/drm/virtio/virtgpu_drm_bus.c
@@ -27,16 +27,6 @@
 
 #include "virtgpu_drv.h"
 
-int drm_virtio_set_busid(struct drm_device *dev, struct drm_master *master)
-{
-        struct pci_dev *pdev = dev->pdev;
-
-        if (pdev) {
-                return drm_pci_set_busid(dev, master);
-        }
-        return 0;
-}
-
 static void virtio_pci_kick_out_firmware_fb(struct pci_dev *pci_dev)
 {
         struct apertures_struct *ap;
diff --git a/drivers/gpu/drm/virtio/virtgpu_drv.c b/drivers/gpu/drm/virtio/virtgpu_drv.c
index 5820b7020ae5..c13f70cfc461 100644
--- a/drivers/gpu/drm/virtio/virtgpu_drv.c
+++ b/drivers/gpu/drm/virtio/virtgpu_drv.c
@@ -117,7 +117,6 @@ static const struct file_operations virtio_gpu_driver_fops = {
 
 static struct drm_driver driver = {
         .driver_features = DRIVER_MODESET | DRIVER_GEM | DRIVER_PRIME | DRIVER_RENDER | DRIVER_ATOMIC,
-        .set_busid = drm_virtio_set_busid,
         .load = virtio_gpu_driver_load,
         .unload = virtio_gpu_driver_unload,
         .open = virtio_gpu_driver_open,
diff --git a/drivers/gpu/drm/virtio/virtgpu_drv.h b/drivers/gpu/drm/virtio/virtgpu_drv.h
index acf556a35cb2..b18ef3111f0c 100644
--- a/drivers/gpu/drm/virtio/virtgpu_drv.h
+++ b/drivers/gpu/drm/virtio/virtgpu_drv.h
@@ -49,7 +49,6 @@
 #define DRIVER_PATCHLEVEL 1
 
 /* virtgpu_drm_bus.c */
-int drm_virtio_set_busid(struct drm_device *dev, struct drm_master *master);
 int drm_virtio_init(struct drm_driver *driver, struct virtio_device *vdev);
 
 struct virtio_gpu_object {
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_drv.c b/drivers/gpu/drm/vmwgfx/vmwgfx_drv.c
index 9fcd8200d485..60646644bef3 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_drv.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_drv.c
@@ -1049,7 +1049,7 @@ static struct vmw_master *vmw_master_check(struct drm_device *dev,
         if (unlikely(ret != 0))
                 return ERR_PTR(-ERESTARTSYS);
 
-        if (file_priv->is_master) {
+        if (drm_is_current_master(file_priv)) {
                 mutex_unlock(&dev->master_mutex);
                 return NULL;
         }
@@ -1228,8 +1228,7 @@ static int vmw_master_set(struct drm_device *dev,
 }
 
 static void vmw_master_drop(struct drm_device *dev,
-                            struct drm_file *file_priv,
-                            bool from_release)
+                            struct drm_file *file_priv)
 {
         struct vmw_private *dev_priv = vmw_priv(dev);
         struct vmw_fpriv *vmw_fp = vmw_fpriv(file_priv);
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_drv.h b/drivers/gpu/drm/vmwgfx/vmwgfx_drv.h
index 1980e2a28265..9a90f824814e 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_drv.h
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_drv.h
@@ -32,6 +32,7 @@
 #include <drm/drmP.h>
 #include <drm/vmwgfx_drm.h>
 #include <drm/drm_hashtab.h>
+#include <drm/drm_auth.h>
 #include <linux/suspend.h>
 #include <drm/ttm/ttm_bo_driver.h>
 #include <drm/ttm/ttm_object.h>