#define ACCEL_DEBUGFS_ENTRIES ARRAY_SIZE(accel_debugfs_list)
 
 /**
- * accel_debugfs_init() - Initialize debugfs for accel minor
- * @minor: Pointer to the drm_minor instance.
- * @minor_id: The minor's id
+ * accel_debugfs_init() - Initialize debugfs for device
+ * @dev: Pointer to the device instance.
  *
- * This function initializes the drm minor's debugfs members and creates
- * a root directory for the minor in debugfs. It also creates common files
- * for accelerators and calls the driver's debugfs init callback.
+ * This function creates a root directory for the device in debugfs.
  */
-void accel_debugfs_init(struct drm_minor *minor, int minor_id)
+void accel_debugfs_init(struct drm_device *dev)
 {
-       struct drm_device *dev = minor->dev;
-       char name[64];
+       drm_debugfs_dev_init(dev, accel_debugfs_root);
+}
+
+/**
+ * accel_debugfs_register() - Register debugfs for device
+ * @dev: Pointer to the device instance.
+ *
+ * Creates common files for accelerators.
+ */
+void accel_debugfs_register(struct drm_device *dev)
+{
+       struct drm_minor *minor = dev->accel;
 
        INIT_LIST_HEAD(&minor->debugfs_list);
        mutex_init(&minor->debugfs_lock);
-       sprintf(name, "%d", minor_id);
-       minor->debugfs_root = debugfs_create_dir(name, accel_debugfs_root);
+       minor->debugfs_root = dev->debugfs_root;
 
        drm_debugfs_create_files(accel_debugfs_list, ACCEL_DEBUGFS_ENTRIES,
-                                minor->debugfs_root, minor);
+                                dev->debugfs_root, minor);
 }
 
 /**
 
        {"state", drm_state_info, 0},
 };
 
-void drm_atomic_debugfs_init(struct drm_minor *minor)
+void drm_atomic_debugfs_init(struct drm_device *dev)
 {
-       drm_debugfs_add_files(minor->dev, drm_atomic_debugfs_list,
+       drm_debugfs_add_files(dev, drm_atomic_debugfs_list,
                              ARRAY_SIZE(drm_atomic_debugfs_list));
 }
 #endif
 
        { "bridge_chains", drm_bridge_chains_info, 0 },
 };
 
-void drm_bridge_debugfs_init(struct drm_minor *minor)
+void drm_bridge_debugfs_init(struct drm_device *dev)
 {
-       drm_debugfs_add_files(minor->dev, drm_bridge_debugfs_list,
+       drm_debugfs_add_files(dev, drm_bridge_debugfs_list,
                              ARRAY_SIZE(drm_bridge_debugfs_list));
 }
 #endif
 
        { "internal_clients", drm_client_debugfs_internal_clients, 0 },
 };
 
-void drm_client_debugfs_init(struct drm_minor *minor)
+void drm_client_debugfs_init(struct drm_device *dev)
 {
-       drm_debugfs_add_files(minor->dev, drm_client_debugfs_list,
+       drm_debugfs_add_files(dev, drm_client_debugfs_list,
                              ARRAY_SIZE(drm_client_debugfs_list));
 }
 #endif
 
 /* drm_atomic.c */
 #ifdef CONFIG_DEBUG_FS
 struct drm_minor;
-void drm_atomic_debugfs_init(struct drm_minor *minor);
+void drm_atomic_debugfs_init(struct drm_device *dev);
 #endif
 
 int __drm_atomic_helper_disable_plane(struct drm_plane *plane,
 
 }
 EXPORT_SYMBOL(drm_debugfs_create_files);
 
-int drm_debugfs_init(struct drm_minor *minor, int minor_id,
-                    struct dentry *root)
+/**
+ * drm_debugfs_dev_init - create debugfs directory for the device
+ * @dev: the device which we want to create the directory for
+ * @root: the parent directory depending on the device type
+ *
+ * Creates the debugfs directory for the device under the given root directory.
+ */
+void drm_debugfs_dev_init(struct drm_device *dev, struct dentry *root)
+{
+       dev->debugfs_root = debugfs_create_dir(dev->unique, root);
+}
+
+/**
+ * drm_debugfs_dev_fini - cleanup debugfs directory
+ * @dev: the device to cleanup the debugfs stuff
+ *
+ * Remove the debugfs directory, might be called multiple times.
+ */
+void drm_debugfs_dev_fini(struct drm_device *dev)
+{
+       debugfs_remove_recursive(dev->debugfs_root);
+       dev->debugfs_root = NULL;
+}
+
+void drm_debugfs_dev_register(struct drm_device *dev)
+{
+       drm_debugfs_add_files(dev, drm_debugfs_list, DRM_DEBUGFS_ENTRIES);
+
+       if (drm_core_check_feature(dev, DRIVER_MODESET)) {
+               drm_framebuffer_debugfs_init(dev);
+               drm_client_debugfs_init(dev);
+       }
+       if (drm_drv_uses_atomic_modeset(dev)) {
+               drm_atomic_debugfs_init(dev);
+               drm_bridge_debugfs_init(dev);
+       }
+}
+
+int drm_debugfs_register(struct drm_minor *minor, int minor_id,
+                        struct dentry *root)
 {
        struct drm_device *dev = minor->dev;
        struct drm_debugfs_entry *entry, *tmp;
        INIT_LIST_HEAD(&minor->debugfs_list);
        mutex_init(&minor->debugfs_lock);
        sprintf(name, "%d", minor_id);
-       minor->debugfs_root = debugfs_create_dir(name, root);
-
-       drm_debugfs_add_files(minor->dev, drm_debugfs_list, DRM_DEBUGFS_ENTRIES);
+       minor->debugfs_symlink = debugfs_create_symlink(name, root,
+                                                       dev->unique);
 
-       if (drm_drv_uses_atomic_modeset(dev)) {
-               drm_atomic_debugfs_init(minor);
-               drm_bridge_debugfs_init(minor);
-       }
-
-       if (drm_core_check_feature(dev, DRIVER_MODESET)) {
-               drm_framebuffer_debugfs_init(minor);
-
-               drm_client_debugfs_init(minor);
-       }
+       /* TODO: Only for compatibility with drivers */
+       minor->debugfs_root = dev->debugfs_root;
 
        if (dev->driver->debugfs_init && dev->render != minor)
                dev->driver->debugfs_init(minor);
 
 void drm_debugfs_cleanup(struct drm_minor *minor)
 {
-       if (!minor->debugfs_root)
+       if (!minor->debugfs_symlink)
                return;
 
        drm_debugfs_remove_all_files(minor);
-
-       debugfs_remove_recursive(minor->debugfs_root);
-       minor->debugfs_root = NULL;
+       debugfs_remove(minor->debugfs_symlink);
+       minor->debugfs_symlink = NULL;
 }
 
 /**
 
 void drm_debugfs_connector_add(struct drm_connector *connector)
 {
-       struct drm_minor *minor = connector->dev->primary;
+       struct drm_device *dev = connector->dev;
        struct dentry *root;
 
-       if (!minor->debugfs_root)
+       if (!dev->debugfs_root)
                return;
 
-       root = debugfs_create_dir(connector->name, minor->debugfs_root);
+       root = debugfs_create_dir(connector->name, dev->debugfs_root);
        connector->debugfs_entry = root;
 
        /* force */
 
 void drm_debugfs_crtc_add(struct drm_crtc *crtc)
 {
-       struct drm_minor *minor = crtc->dev->primary;
+       struct drm_device *dev = crtc->dev;
        struct dentry *root;
        char *name;
 
        if (!name)
                return;
 
-       root = debugfs_create_dir(name, minor->debugfs_root);
+       root = debugfs_create_dir(name, dev->debugfs_root);
        kfree(name);
 
        crtc->debugfs_entry = root;
 
        if (!minor)
                return 0;
 
-       if (minor->type == DRM_MINOR_ACCEL) {
-               accel_debugfs_init(minor, minor->index);
-       } else {
-               ret = drm_debugfs_init(minor, minor->index, drm_debugfs_root);
+       if (minor->type != DRM_MINOR_ACCEL) {
+               ret = drm_debugfs_register(minor, minor->index,
+                                          drm_debugfs_root);
                if (ret) {
                        DRM_ERROR("DRM: Failed to initialize /sys/kernel/debug/dri.\n");
                        goto err_debugfs;
                goto err;
        }
 
+       if (drm_core_check_feature(dev, DRIVER_COMPUTE_ACCEL))
+               accel_debugfs_init(dev);
+       else
+               drm_debugfs_dev_init(dev, drm_debugfs_root);
+
        return 0;
 
 err:
 {
        struct drm_device *dev = container_of(ref, struct drm_device, ref);
 
+       /* Just in case register/unregister was never called */
+       drm_debugfs_dev_fini(dev);
+
        if (dev->driver->release)
                dev->driver->release(dev);
 
        if (drm_dev_needs_global_mutex(dev))
                mutex_lock(&drm_global_mutex);
 
+       if (drm_core_check_feature(dev, DRIVER_COMPUTE_ACCEL))
+               accel_debugfs_register(dev);
+       else
+               drm_debugfs_dev_register(dev);
+
        ret = drm_minor_register(dev, DRM_MINOR_RENDER);
        if (ret)
                goto err_minors;
        drm_minor_unregister(dev, DRM_MINOR_ACCEL);
        drm_minor_unregister(dev, DRM_MINOR_PRIMARY);
        drm_minor_unregister(dev, DRM_MINOR_RENDER);
+       drm_debugfs_dev_fini(dev);
 }
 EXPORT_SYMBOL(drm_dev_unregister);
 
 
        { "framebuffer", drm_framebuffer_info, 0 },
 };
 
-void drm_framebuffer_debugfs_init(struct drm_minor *minor)
+void drm_framebuffer_debugfs_init(struct drm_device *dev)
 {
-       drm_debugfs_add_files(minor->dev, drm_framebuffer_debugfs_list,
+       drm_debugfs_add_files(dev, drm_framebuffer_debugfs_list,
                              ARRAY_SIZE(drm_framebuffer_debugfs_list));
 }
 #endif
 
 
 /* drm_debugfs.c drm_debugfs_crc.c */
 #if defined(CONFIG_DEBUG_FS)
-int drm_debugfs_init(struct drm_minor *minor, int minor_id,
-                    struct dentry *root);
+void drm_debugfs_dev_fini(struct drm_device *dev);
+void drm_debugfs_dev_register(struct drm_device *dev);
+int drm_debugfs_register(struct drm_minor *minor, int minor_id,
+                        struct dentry *root);
 void drm_debugfs_cleanup(struct drm_minor *minor);
 void drm_debugfs_late_register(struct drm_device *dev);
 void drm_debugfs_connector_add(struct drm_connector *connector);
 void drm_debugfs_crtc_remove(struct drm_crtc *crtc);
 void drm_debugfs_crtc_crc_add(struct drm_crtc *crtc);
 #else
-static inline int drm_debugfs_init(struct drm_minor *minor, int minor_id,
-                                  struct dentry *root)
+static inline void drm_debugfs_dev_fini(struct drm_device *dev)
+{
+}
+
+static inline void drm_debugfs_dev_register(struct drm_device *dev)
+{
+}
+
+static inline int drm_debugfs_register(struct drm_minor *minor, int minor_id,
+                                      struct dentry *root)
 {
        return 0;
 }
 /* drm_framebuffer.c */
 void drm_framebuffer_print_info(struct drm_printer *p, unsigned int indent,
                                const struct drm_framebuffer *fb);
-void drm_framebuffer_debugfs_init(struct drm_minor *minor);
+void drm_framebuffer_debugfs_init(struct drm_device *dev);
 
 void accel_minor_replace(struct drm_minor *minor, int index);
 void accel_set_device_instance_params(struct device *kdev, int index);
 int accel_open(struct inode *inode, struct file *filp);
-void accel_debugfs_init(struct drm_minor *minor, int minor_id);
+void accel_debugfs_init(struct drm_device *dev);
+void accel_debugfs_register(struct drm_device *dev);
 
 #else
 
 {
 }
 
-static inline void accel_debugfs_init(struct drm_minor *minor, int minor_id)
+static inline void accel_debugfs_init(struct drm_device *dev)
+{
+}
+
+static inline void accel_debugfs_register(struct drm_device *dev)
 {
 }
 
 
 }
 #endif
 
-void drm_bridge_debugfs_init(struct drm_minor *minor);
+void drm_bridge_debugfs_init(struct drm_device *dev);
 
 #endif
 
        drm_for_each_connector_iter(connector, iter) \
                if (connector->connector_type != DRM_MODE_CONNECTOR_WRITEBACK)
 
-void drm_client_debugfs_init(struct drm_minor *minor);
+void drm_client_debugfs_init(struct drm_device *dev);
 
 #endif
 
         */
        struct drm_fb_helper *fb_helper;
 
+       /**
+        * @debugfs_root:
+        *
+        * Root directory for debugfs files.
+        */
+       struct dentry *debugfs_root;
+
        /**
         * @debugfs_mutex:
         *
 
        return video_firmware_drivers_only();
 }
 
+#if defined(CONFIG_DEBUG_FS)
+void drm_debugfs_dev_init(struct drm_device *dev, struct dentry *root);
+#else
+static void drm_debugfs_dev_init(struct drm_device *dev, struct dentry *root)
+{
+}
+#endif
+
 #endif
 
        struct device *kdev;            /* Linux device */
        struct drm_device *dev;
 
+       struct dentry *debugfs_symlink;
        struct dentry *debugfs_root;
 
        struct list_head debugfs_list;